{"version":3,"file":"static/js/vendors-7eb22e3e.d8ff45ca.js","mappings":"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","sources":["../node_modules/@emotion/sheet/dist/emotion-sheet.esm.js","../node_modules/@emotion/cache/dist/emotion-cache.browser.esm.js","../node_modules/@emotion/memoize/dist/emotion-memoize.esm.js","../node_modules/@emotion/react/_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js","../node_modules/@emotion/react/dist/emotion-element-f0de968e.browser.esm.js","../node_modules/@emotion/react/dist/emotion-react.browser.esm.js","../node_modules/@emotion/unitless/dist/emotion-unitless.esm.js","../node_modules/@emotion/serialize/dist/emotion-serialize.esm.js","../node_modules/@emotion/hash/dist/emotion-hash.esm.js","../node_modules/@emotion/is-prop-valid/dist/emotion-is-prop-valid.esm.js","../node_modules/@emotion/styled/base/dist/emotion-styled-base.browser.esm.js","../node_modules/@emotion/styled/dist/emotion-styled.browser.esm.js","../node_modules/@emotion/use-insertion-effect-with-fallbacks/dist/emotion-use-insertion-effect-with-fallbacks.browser.esm.js","../node_modules/@emotion/utils/dist/emotion-utils.browser.esm.js","../node_modules/@emotion/weak-memoize/dist/emotion-weak-memoize.esm.js","../node_modules/embla-carousel-reactive-utils/src/components/utils.ts","../node_modules/embla-carousel/src/components/utils.ts","../node_modules/embla-carousel/src/components/EventStore.ts","../node_modules/embla-carousel/src/components/Animations.ts","../node_modules/embla-carousel/src/components/Limit.ts","../node_modules/embla-carousel/src/components/Counter.ts","../node_modules/embla-carousel/src/components/DragHandler.ts","../node_modules/embla-carousel/src/components/DragTracker.ts","../node_modules/embla-carousel/src/components/ResizeHandler.ts","../node_modules/embla-carousel/src/components/ScrollBounds.ts","../node_modules/embla-carousel/src/components/ScrollLooper.ts","../node_modules/embla-carousel/src/components/ScrollTarget.ts","../node_modules/embla-carousel/src/components/SlideFocus.ts","../node_modules/embla-carousel/src/components/Vector1d.ts","../node_modules/embla-carousel/src/components/Translate.ts","../node_modules/embla-carousel/src/components/SlideLooper.ts","../node_modules/embla-carousel/src/components/SlidesHandler.ts","../node_modules/embla-carousel/src/components/SlidesInView.ts","../node_modules/embla-carousel/src/components/SlidesToScroll.ts","../node_modules/embla-carousel/src/components/Engine.ts","../node_modules/embla-carousel/src/components/NodeRects.ts","../node_modules/embla-carousel/src/components/Axis.ts","../node_modules/embla-carousel/src/components/PercentOfView.ts","../node_modules/embla-carousel/src/components/Alignment.ts","../node_modules/embla-carousel/src/components/SlideSizes.ts","../node_modules/embla-carousel/src/components/ScrollSnaps.ts","../node_modules/embla-carousel/src/components/ScrollContain.ts","../node_modules/embla-carousel/src/components/ScrollLimit.ts","../node_modules/embla-carousel/src/components/ScrollBody.ts","../node_modules/embla-carousel/src/components/ScrollTo.ts","../node_modules/embla-carousel/src/components/ScrollProgress.ts","../node_modules/embla-carousel/src/components/SlideRegistry.ts","../node_modules/embla-carousel/src/components/Options.ts","../node_modules/embla-carousel/src/components/OptionsHandler.ts","../node_modules/embla-carousel/src/components/EmblaCarousel.ts","../node_modules/embla-carousel/src/components/PluginsHandler.ts","../node_modules/embla-carousel/src/components/EventHandler.ts","../node_modules/embla-carousel-react/src/components/useEmblaCarousel.ts","../node_modules/engine.io-parser/build/esm/commons.js","../node_modules/engine.io-parser/build/esm/encodePacket.browser.js","../node_modules/engine.io-parser/build/esm/contrib/base64-arraybuffer.js","../node_modules/engine.io-parser/build/esm/decodePacket.browser.js","../node_modules/engine.io-parser/build/esm/index.js","../node_modules/engine.io-client/build/esm/globals.js","../node_modules/engine.io-client/build/esm/util.js","../node_modules/engine.io-client/build/esm/transport.js","../node_modules/engine.io-client/build/esm/contrib/parseqs.js","../node_modules/engine.io-client/build/esm/transports/polling.js","../node_modules/engine.io-client/build/esm/contrib/has-cors.js","../node_modules/engine.io-client/build/esm/transports/polling-xhr.js","../node_modules/engine.io-client/build/esm/transports/websocket.js","../node_modules/engine.io-client/build/esm/transports/index.js","../node_modules/engine.io-client/build/esm/transports/webtransport.js","../node_modules/engine.io-client/build/esm/contrib/parseuri.js","../node_modules/engine.io-client/build/esm/socket.js"],"sourcesContent":["var isDevelopment = false;\n\n/*\n\nBased off glamor's StyleSheet, thanks Sunil ❤️\n\nhigh performance StyleSheet for css-in-js systems\n\n- uses multiple style tags behind the scenes for millions of rules\n- uses `insertRule` for appending in production for *much* faster performance\n\n// usage\n\nimport { StyleSheet } from '@emotion/sheet'\n\nlet styleSheet = new StyleSheet({ key: '', container: document.head })\n\nstyleSheet.insert('#box { border: 1px solid red; }')\n- appends a css rule into the stylesheet\n\nstyleSheet.flush()\n- empties the stylesheet of all its contents\n\n*/\n\nfunction sheetForTag(tag) {\n  if (tag.sheet) {\n    return tag.sheet;\n  } // this weirdness brought to you by firefox\n\n  /* istanbul ignore next */\n\n\n  for (var i = 0; i < document.styleSheets.length; i++) {\n    if (document.styleSheets[i].ownerNode === tag) {\n      return document.styleSheets[i];\n    }\n  } // this function should always return with a value\n  // TS can't understand it though so we make it stop complaining here\n\n\n  return undefined;\n}\n\nfunction createStyleElement(options) {\n  var tag = document.createElement('style');\n  tag.setAttribute('data-emotion', options.key);\n\n  if (options.nonce !== undefined) {\n    tag.setAttribute('nonce', options.nonce);\n  }\n\n  tag.appendChild(document.createTextNode(''));\n  tag.setAttribute('data-s', '');\n  return tag;\n}\n\nvar StyleSheet = /*#__PURE__*/function () {\n  // Using Node instead of HTMLElement since container may be a ShadowRoot\n  function StyleSheet(options) {\n    var _this = this;\n\n    this._insertTag = function (tag) {\n      var before;\n\n      if (_this.tags.length === 0) {\n        if (_this.insertionPoint) {\n          before = _this.insertionPoint.nextSibling;\n        } else if (_this.prepend) {\n          before = _this.container.firstChild;\n        } else {\n          before = _this.before;\n        }\n      } else {\n        before = _this.tags[_this.tags.length - 1].nextSibling;\n      }\n\n      _this.container.insertBefore(tag, before);\n\n      _this.tags.push(tag);\n    };\n\n    this.isSpeedy = options.speedy === undefined ? !isDevelopment : options.speedy;\n    this.tags = [];\n    this.ctr = 0;\n    this.nonce = options.nonce; // key is the value of the data-emotion attribute, it's used to identify different sheets\n\n    this.key = options.key;\n    this.container = options.container;\n    this.prepend = options.prepend;\n    this.insertionPoint = options.insertionPoint;\n    this.before = null;\n  }\n\n  var _proto = StyleSheet.prototype;\n\n  _proto.hydrate = function hydrate(nodes) {\n    nodes.forEach(this._insertTag);\n  };\n\n  _proto.insert = function insert(rule) {\n    // the max length is how many rules we have per style tag, it's 65000 in speedy mode\n    // it's 1 in dev because we insert source maps that map a single rule to a location\n    // and you can only have one source map per style tag\n    if (this.ctr % (this.isSpeedy ? 65000 : 1) === 0) {\n      this._insertTag(createStyleElement(this));\n    }\n\n    var tag = this.tags[this.tags.length - 1];\n\n    if (this.isSpeedy) {\n      var sheet = sheetForTag(tag);\n\n      try {\n        // this is the ultrafast version, works across browsers\n        // the big drawback is that the css won't be editable in devtools\n        sheet.insertRule(rule, sheet.cssRules.length);\n      } catch (e) {\n      }\n    } else {\n      tag.appendChild(document.createTextNode(rule));\n    }\n\n    this.ctr++;\n  };\n\n  _proto.flush = function flush() {\n    this.tags.forEach(function (tag) {\n      var _tag$parentNode;\n\n      return (_tag$parentNode = tag.parentNode) == null ? void 0 : _tag$parentNode.removeChild(tag);\n    });\n    this.tags = [];\n    this.ctr = 0;\n  };\n\n  return StyleSheet;\n}();\n\nexport { StyleSheet };\n","import { StyleSheet } from '@emotion/sheet';\nimport { dealloc, alloc, next, token, from, peek, delimit, slice, position, RULESET, combine, match, serialize, copy, replace, WEBKIT, MOZ, MS, KEYFRAMES, DECLARATION, hash, charat, strlen, indexof, stringify, rulesheet, middleware, compile } from 'stylis';\nimport '@emotion/weak-memoize';\nimport '@emotion/memoize';\n\nvar identifierWithPointTracking = function identifierWithPointTracking(begin, points, index) {\n  var previous = 0;\n  var character = 0;\n\n  while (true) {\n    previous = character;\n    character = peek(); // &\\f\n\n    if (previous === 38 && character === 12) {\n      points[index] = 1;\n    }\n\n    if (token(character)) {\n      break;\n    }\n\n    next();\n  }\n\n  return slice(begin, position);\n};\n\nvar toRules = function toRules(parsed, points) {\n  // pretend we've started with a comma\n  var index = -1;\n  var character = 44;\n\n  do {\n    switch (token(character)) {\n      case 0:\n        // &\\f\n        if (character === 38 && peek() === 12) {\n          // this is not 100% correct, we don't account for literal sequences here - like for example quoted strings\n          // stylis inserts \\f after & to know when & where it should replace this sequence with the context selector\n          // and when it should just concatenate the outer and inner selectors\n          // it's very unlikely for this sequence to actually appear in a different context, so we just leverage this fact here\n          points[index] = 1;\n        }\n\n        parsed[index] += identifierWithPointTracking(position - 1, points, index);\n        break;\n\n      case 2:\n        parsed[index] += delimit(character);\n        break;\n\n      case 4:\n        // comma\n        if (character === 44) {\n          // colon\n          parsed[++index] = peek() === 58 ? '&\\f' : '';\n          points[index] = parsed[index].length;\n          break;\n        }\n\n      // fallthrough\n\n      default:\n        parsed[index] += from(character);\n    }\n  } while (character = next());\n\n  return parsed;\n};\n\nvar getRules = function getRules(value, points) {\n  return dealloc(toRules(alloc(value), points));\n}; // WeakSet would be more appropriate, but only WeakMap is supported in IE11\n\n\nvar fixedElements = /* #__PURE__ */new WeakMap();\nvar compat = function compat(element) {\n  if (element.type !== 'rule' || !element.parent || // positive .length indicates that this rule contains pseudo\n  // negative .length indicates that this rule has been already prefixed\n  element.length < 1) {\n    return;\n  }\n\n  var value = element.value;\n  var parent = element.parent;\n  var isImplicitRule = element.column === parent.column && element.line === parent.line;\n\n  while (parent.type !== 'rule') {\n    parent = parent.parent;\n    if (!parent) return;\n  } // short-circuit for the simplest case\n\n\n  if (element.props.length === 1 && value.charCodeAt(0) !== 58\n  /* colon */\n  && !fixedElements.get(parent)) {\n    return;\n  } // if this is an implicitly inserted rule (the one eagerly inserted at the each new nested level)\n  // then the props has already been manipulated beforehand as they that array is shared between it and its \"rule parent\"\n\n\n  if (isImplicitRule) {\n    return;\n  }\n\n  fixedElements.set(element, true);\n  var points = [];\n  var rules = getRules(value, points);\n  var parentRules = parent.props;\n\n  for (var i = 0, k = 0; i < rules.length; i++) {\n    for (var j = 0; j < parentRules.length; j++, k++) {\n      element.props[k] = points[i] ? rules[i].replace(/&\\f/g, parentRules[j]) : parentRules[j] + \" \" + rules[i];\n    }\n  }\n};\nvar removeLabel = function removeLabel(element) {\n  if (element.type === 'decl') {\n    var value = element.value;\n\n    if ( // charcode for l\n    value.charCodeAt(0) === 108 && // charcode for b\n    value.charCodeAt(2) === 98) {\n      // this ignores label\n      element[\"return\"] = '';\n      element.value = '';\n    }\n  }\n};\n\n/* eslint-disable no-fallthrough */\n\nfunction prefix(value, length) {\n  switch (hash(value, length)) {\n    // color-adjust\n    case 5103:\n      return WEBKIT + 'print-' + value + value;\n    // animation, animation-(delay|direction|duration|fill-mode|iteration-count|name|play-state|timing-function)\n\n    case 5737:\n    case 4201:\n    case 3177:\n    case 3433:\n    case 1641:\n    case 4457:\n    case 2921: // text-decoration, filter, clip-path, backface-visibility, column, box-decoration-break\n\n    case 5572:\n    case 6356:\n    case 5844:\n    case 3191:\n    case 6645:\n    case 3005: // mask, mask-image, mask-(mode|clip|size), mask-(repeat|origin), mask-position, mask-composite,\n\n    case 6391:\n    case 5879:\n    case 5623:\n    case 6135:\n    case 4599:\n    case 4855: // background-clip, columns, column-(count|fill|gap|rule|rule-color|rule-style|rule-width|span|width)\n\n    case 4215:\n    case 6389:\n    case 5109:\n    case 5365:\n    case 5621:\n    case 3829:\n      return WEBKIT + value + value;\n    // appearance, user-select, transform, hyphens, text-size-adjust\n\n    case 5349:\n    case 4246:\n    case 4810:\n    case 6968:\n    case 2756:\n      return WEBKIT + value + MOZ + value + MS + value + value;\n    // flex, flex-direction\n\n    case 6828:\n    case 4268:\n      return WEBKIT + value + MS + value + value;\n    // order\n\n    case 6165:\n      return WEBKIT + value + MS + 'flex-' + value + value;\n    // align-items\n\n    case 5187:\n      return WEBKIT + value + replace(value, /(\\w+).+(:[^]+)/, WEBKIT + 'box-$1$2' + MS + 'flex-$1$2') + value;\n    // align-self\n\n    case 5443:\n      return WEBKIT + value + MS + 'flex-item-' + replace(value, /flex-|-self/, '') + value;\n    // align-content\n\n    case 4675:\n      return WEBKIT + value + MS + 'flex-line-pack' + replace(value, /align-content|flex-|-self/, '') + value;\n    // flex-shrink\n\n    case 5548:\n      return WEBKIT + value + MS + replace(value, 'shrink', 'negative') + value;\n    // flex-basis\n\n    case 5292:\n      return WEBKIT + value + MS + replace(value, 'basis', 'preferred-size') + value;\n    // flex-grow\n\n    case 6060:\n      return WEBKIT + 'box-' + replace(value, '-grow', '') + WEBKIT + value + MS + replace(value, 'grow', 'positive') + value;\n    // transition\n\n    case 4554:\n      return WEBKIT + replace(value, /([^-])(transform)/g, '$1' + WEBKIT + '$2') + value;\n    // cursor\n\n    case 6187:\n      return replace(replace(replace(value, /(zoom-|grab)/, WEBKIT + '$1'), /(image-set)/, WEBKIT + '$1'), value, '') + value;\n    // background, background-image\n\n    case 5495:\n    case 3959:\n      return replace(value, /(image-set\\([^]*)/, WEBKIT + '$1' + '$`$1');\n    // justify-content\n\n    case 4968:\n      return replace(replace(value, /(.+:)(flex-)?(.*)/, WEBKIT + 'box-pack:$3' + MS + 'flex-pack:$3'), /s.+-b[^;]+/, 'justify') + WEBKIT + value + value;\n    // (margin|padding)-inline-(start|end)\n\n    case 4095:\n    case 3583:\n    case 4068:\n    case 2532:\n      return replace(value, /(.+)-inline(.+)/, WEBKIT + '$1$2') + value;\n    // (min|max)?(width|height|inline-size|block-size)\n\n    case 8116:\n    case 7059:\n    case 5753:\n    case 5535:\n    case 5445:\n    case 5701:\n    case 4933:\n    case 4677:\n    case 5533:\n    case 5789:\n    case 5021:\n    case 4765:\n      // stretch, max-content, min-content, fill-available\n      if (strlen(value) - 1 - length > 6) switch (charat(value, length + 1)) {\n        // (m)ax-content, (m)in-content\n        case 109:\n          // -\n          if (charat(value, length + 4) !== 45) break;\n        // (f)ill-available, (f)it-content\n\n        case 102:\n          return replace(value, /(.+:)(.+)-([^]+)/, '$1' + WEBKIT + '$2-$3' + '$1' + MOZ + (charat(value, length + 3) == 108 ? '$3' : '$2-$3')) + value;\n        // (s)tretch\n\n        case 115:\n          return ~indexof(value, 'stretch') ? prefix(replace(value, 'stretch', 'fill-available'), length) + value : value;\n      }\n      break;\n    // position: sticky\n\n    case 4949:\n      // (s)ticky?\n      if (charat(value, length + 1) !== 115) break;\n    // display: (flex|inline-flex)\n\n    case 6444:\n      switch (charat(value, strlen(value) - 3 - (~indexof(value, '!important') && 10))) {\n        // stic(k)y\n        case 107:\n          return replace(value, ':', ':' + WEBKIT) + value;\n        // (inline-)?fl(e)x\n\n        case 101:\n          return replace(value, /(.+:)([^;!]+)(;|!.+)?/, '$1' + WEBKIT + (charat(value, 14) === 45 ? 'inline-' : '') + 'box$3' + '$1' + WEBKIT + '$2$3' + '$1' + MS + '$2box$3') + value;\n      }\n\n      break;\n    // writing-mode\n\n    case 5936:\n      switch (charat(value, length + 11)) {\n        // vertical-l(r)\n        case 114:\n          return WEBKIT + value + MS + replace(value, /[svh]\\w+-[tblr]{2}/, 'tb') + value;\n        // vertical-r(l)\n\n        case 108:\n          return WEBKIT + value + MS + replace(value, /[svh]\\w+-[tblr]{2}/, 'tb-rl') + value;\n        // horizontal(-)tb\n\n        case 45:\n          return WEBKIT + value + MS + replace(value, /[svh]\\w+-[tblr]{2}/, 'lr') + value;\n      }\n\n      return WEBKIT + value + MS + value + value;\n  }\n\n  return value;\n}\n\nvar prefixer = function prefixer(element, index, children, callback) {\n  if (element.length > -1) if (!element[\"return\"]) switch (element.type) {\n    case DECLARATION:\n      element[\"return\"] = prefix(element.value, element.length);\n      break;\n\n    case KEYFRAMES:\n      return serialize([copy(element, {\n        value: replace(element.value, '@', '@' + WEBKIT)\n      })], callback);\n\n    case RULESET:\n      if (element.length) return combine(element.props, function (value) {\n        switch (match(value, /(::plac\\w+|:read-\\w+)/)) {\n          // :read-(only|write)\n          case ':read-only':\n          case ':read-write':\n            return serialize([copy(element, {\n              props: [replace(value, /:(read-\\w+)/, ':' + MOZ + '$1')]\n            })], callback);\n          // :placeholder\n\n          case '::placeholder':\n            return serialize([copy(element, {\n              props: [replace(value, /:(plac\\w+)/, ':' + WEBKIT + 'input-$1')]\n            }), copy(element, {\n              props: [replace(value, /:(plac\\w+)/, ':' + MOZ + '$1')]\n            }), copy(element, {\n              props: [replace(value, /:(plac\\w+)/, MS + 'input-$1')]\n            })], callback);\n        }\n\n        return '';\n      });\n  }\n};\n\nvar defaultStylisPlugins = [prefixer];\n\nvar createCache = function createCache(options) {\n  var key = options.key;\n\n  if (key === 'css') {\n    var ssrStyles = document.querySelectorAll(\"style[data-emotion]:not([data-s])\"); // get SSRed styles out of the way of React's hydration\n    // document.head is a safe place to move them to(though note document.head is not necessarily the last place they will be)\n    // note this very very intentionally targets all style elements regardless of the key to ensure\n    // that creating a cache works inside of render of a React component\n\n    Array.prototype.forEach.call(ssrStyles, function (node) {\n      // we want to only move elements which have a space in the data-emotion attribute value\n      // because that indicates that it is an Emotion 11 server-side rendered style elements\n      // while we will already ignore Emotion 11 client-side inserted styles because of the :not([data-s]) part in the selector\n      // Emotion 10 client-side inserted styles did not have data-s (but importantly did not have a space in their data-emotion attributes)\n      // so checking for the space ensures that loading Emotion 11 after Emotion 10 has inserted some styles\n      // will not result in the Emotion 10 styles being destroyed\n      var dataEmotionAttribute = node.getAttribute('data-emotion');\n\n      if (dataEmotionAttribute.indexOf(' ') === -1) {\n        return;\n      }\n\n      document.head.appendChild(node);\n      node.setAttribute('data-s', '');\n    });\n  }\n\n  var stylisPlugins = options.stylisPlugins || defaultStylisPlugins;\n\n  var inserted = {};\n  var container;\n  var nodesToHydrate = [];\n\n  {\n    container = options.container || document.head;\n    Array.prototype.forEach.call( // this means we will ignore elements which don't have a space in them which\n    // means that the style elements we're looking at are only Emotion 11 server-rendered style elements\n    document.querySelectorAll(\"style[data-emotion^=\\\"\" + key + \" \\\"]\"), function (node) {\n      var attrib = node.getAttribute(\"data-emotion\").split(' ');\n\n      for (var i = 1; i < attrib.length; i++) {\n        inserted[attrib[i]] = true;\n      }\n\n      nodesToHydrate.push(node);\n    });\n  }\n\n  var _insert;\n\n  var omnipresentPlugins = [compat, removeLabel];\n\n  {\n    var currentSheet;\n    var finalizingPlugins = [stringify, rulesheet(function (rule) {\n      currentSheet.insert(rule);\n    })];\n    var serializer = middleware(omnipresentPlugins.concat(stylisPlugins, finalizingPlugins));\n\n    var stylis = function stylis(styles) {\n      return serialize(compile(styles), serializer);\n    };\n\n    _insert = function insert(selector, serialized, sheet, shouldCache) {\n      currentSheet = sheet;\n\n      stylis(selector ? selector + \"{\" + serialized.styles + \"}\" : serialized.styles);\n\n      if (shouldCache) {\n        cache.inserted[serialized.name] = true;\n      }\n    };\n  }\n\n  var cache = {\n    key: key,\n    sheet: new StyleSheet({\n      key: key,\n      container: container,\n      nonce: options.nonce,\n      speedy: options.speedy,\n      prepend: options.prepend,\n      insertionPoint: options.insertionPoint\n    }),\n    nonce: options.nonce,\n    inserted: inserted,\n    registered: {},\n    insert: _insert\n  };\n  cache.sheet.hydrate(nodesToHydrate);\n  return cache;\n};\n\nexport { createCache as default };\n","function memoize(fn) {\n  var cache = Object.create(null);\n  return function (arg) {\n    if (cache[arg] === undefined) cache[arg] = fn(arg);\n    return cache[arg];\n  };\n}\n\nexport { memoize as default };\n","import hoistNonReactStatics$1 from 'hoist-non-react-statics';\n\n// this file isolates this package that is not tree-shakeable\n// and if this module doesn't actually contain any logic of its own\n// then Rollup just use 'hoist-non-react-statics' directly in other chunks\n\nvar hoistNonReactStatics = (function (targetComponent, sourceComponent) {\n  return hoistNonReactStatics$1(targetComponent, sourceComponent);\n});\n\nexport { hoistNonReactStatics as default };\n","import * as React from 'react';\nimport { useContext, forwardRef } from 'react';\nimport createCache from '@emotion/cache';\nimport _extends from '@babel/runtime/helpers/esm/extends';\nimport weakMemoize from '@emotion/weak-memoize';\nimport hoistNonReactStatics from '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';\nimport { getRegisteredStyles, registerStyles, insertStyles } from '@emotion/utils';\nimport { serializeStyles } from '@emotion/serialize';\nimport { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';\n\nvar isDevelopment = false;\n\nvar EmotionCacheContext = /* #__PURE__ */React.createContext( // we're doing this to avoid preconstruct's dead code elimination in this one case\n// because this module is primarily intended for the browser and node\n// but it's also required in react native and similar environments sometimes\n// and we could have a special build just for that\n// but this is much easier and the native packages\n// might use a different theme context in the future anyway\ntypeof HTMLElement !== 'undefined' ? /* #__PURE__ */createCache({\n  key: 'css'\n}) : null);\n\nvar CacheProvider = EmotionCacheContext.Provider;\nvar __unsafe_useEmotionCache = function useEmotionCache() {\n  return useContext(EmotionCacheContext);\n};\n\nvar withEmotionCache = function withEmotionCache(func) {\n  return /*#__PURE__*/forwardRef(function (props, ref) {\n    // the cache will never be null in the browser\n    var cache = useContext(EmotionCacheContext);\n    return func(props, cache, ref);\n  });\n};\n\nvar ThemeContext = /* #__PURE__ */React.createContext({});\n\nvar useTheme = function useTheme() {\n  return React.useContext(ThemeContext);\n};\n\nvar getTheme = function getTheme(outerTheme, theme) {\n  if (typeof theme === 'function') {\n    var mergedTheme = theme(outerTheme);\n\n    return mergedTheme;\n  }\n\n  return _extends({}, outerTheme, theme);\n};\n\nvar createCacheWithTheme = /* #__PURE__ */weakMemoize(function (outerTheme) {\n  return weakMemoize(function (theme) {\n    return getTheme(outerTheme, theme);\n  });\n});\nvar ThemeProvider = function ThemeProvider(props) {\n  var theme = React.useContext(ThemeContext);\n\n  if (props.theme !== theme) {\n    theme = createCacheWithTheme(theme)(props.theme);\n  }\n\n  return /*#__PURE__*/React.createElement(ThemeContext.Provider, {\n    value: theme\n  }, props.children);\n};\nfunction withTheme(Component) {\n  var componentName = Component.displayName || Component.name || 'Component';\n  var WithTheme = /*#__PURE__*/React.forwardRef(function render(props, ref) {\n    var theme = React.useContext(ThemeContext);\n    return /*#__PURE__*/React.createElement(Component, _extends({\n      theme: theme,\n      ref: ref\n    }, props));\n  });\n  WithTheme.displayName = \"WithTheme(\" + componentName + \")\";\n  return hoistNonReactStatics(WithTheme, Component);\n}\n\nvar hasOwn = {}.hasOwnProperty;\n\nvar typePropName = '__EMOTION_TYPE_PLEASE_DO_NOT_USE__';\nvar createEmotionProps = function createEmotionProps(type, props) {\n\n  var newProps = {};\n\n  for (var _key in props) {\n    if (hasOwn.call(props, _key)) {\n      newProps[_key] = props[_key];\n    }\n  }\n\n  newProps[typePropName] = type; // Runtime labeling is an opt-in feature because:\n\n  return newProps;\n};\n\nvar Insertion = function Insertion(_ref) {\n  var cache = _ref.cache,\n      serialized = _ref.serialized,\n      isStringTag = _ref.isStringTag;\n  registerStyles(cache, serialized, isStringTag);\n  useInsertionEffectAlwaysWithSyncFallback(function () {\n    return insertStyles(cache, serialized, isStringTag);\n  });\n\n  return null;\n};\n\nvar Emotion = /* #__PURE__ */withEmotionCache(function (props, cache, ref) {\n  var cssProp = props.css; // so that using `css` from `emotion` and passing the result to the css prop works\n  // not passing the registered cache to serializeStyles because it would\n  // make certain babel optimisations not possible\n\n  if (typeof cssProp === 'string' && cache.registered[cssProp] !== undefined) {\n    cssProp = cache.registered[cssProp];\n  }\n\n  var WrappedComponent = props[typePropName];\n  var registeredStyles = [cssProp];\n  var className = '';\n\n  if (typeof props.className === 'string') {\n    className = getRegisteredStyles(cache.registered, registeredStyles, props.className);\n  } else if (props.className != null) {\n    className = props.className + \" \";\n  }\n\n  var serialized = serializeStyles(registeredStyles, undefined, React.useContext(ThemeContext));\n\n  className += cache.key + \"-\" + serialized.name;\n  var newProps = {};\n\n  for (var _key2 in props) {\n    if (hasOwn.call(props, _key2) && _key2 !== 'css' && _key2 !== typePropName && (!isDevelopment )) {\n      newProps[_key2] = props[_key2];\n    }\n  }\n\n  newProps.className = className;\n\n  if (ref) {\n    newProps.ref = ref;\n  }\n\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {\n    cache: cache,\n    serialized: serialized,\n    isStringTag: typeof WrappedComponent === 'string'\n  }), /*#__PURE__*/React.createElement(WrappedComponent, newProps));\n});\n\nvar Emotion$1 = Emotion;\n\nexport { CacheProvider as C, Emotion$1 as E, ThemeContext as T, __unsafe_useEmotionCache as _, ThemeProvider as a, withTheme as b, createEmotionProps as c, hasOwn as h, isDevelopment as i, useTheme as u, withEmotionCache as w };\n","import { h as hasOwn, E as Emotion, c as createEmotionProps, w as withEmotionCache, T as ThemeContext, i as isDevelopment } from './emotion-element-f0de968e.browser.esm.js';\nexport { C as CacheProvider, T as ThemeContext, a as ThemeProvider, _ as __unsafe_useEmotionCache, u as useTheme, w as withEmotionCache, b as withTheme } from './emotion-element-f0de968e.browser.esm.js';\nimport * as React from 'react';\nimport { insertStyles, registerStyles, getRegisteredStyles } from '@emotion/utils';\nimport { useInsertionEffectWithLayoutFallback, useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';\nimport { serializeStyles } from '@emotion/serialize';\nimport '@emotion/cache';\nimport '@babel/runtime/helpers/extends';\nimport '@emotion/weak-memoize';\nimport '../_isolated-hnrs/dist/emotion-react-_isolated-hnrs.browser.esm.js';\nimport 'hoist-non-react-statics';\n\nvar jsx = function jsx(type, props) {\n  // eslint-disable-next-line prefer-rest-params\n  var args = arguments;\n\n  if (props == null || !hasOwn.call(props, 'css')) {\n    return React.createElement.apply(undefined, args);\n  }\n\n  var argsLength = args.length;\n  var createElementArgArray = new Array(argsLength);\n  createElementArgArray[0] = Emotion;\n  createElementArgArray[1] = createEmotionProps(type, props);\n\n  for (var i = 2; i < argsLength; i++) {\n    createElementArgArray[i] = args[i];\n  }\n\n  return React.createElement.apply(null, createElementArgArray);\n};\n\n(function (_jsx) {\n  var JSX;\n\n  (function (_JSX) {})(JSX || (JSX = _jsx.JSX || (_jsx.JSX = {})));\n})(jsx || (jsx = {}));\n\n// initial render from browser, insertBefore context.sheet.tags[0] or if a style hasn't been inserted there yet, appendChild\n// initial client-side render from SSR, use place of hydrating tag\n\nvar Global = /* #__PURE__ */withEmotionCache(function (props, cache) {\n\n  var styles = props.styles;\n  var serialized = serializeStyles([styles], undefined, React.useContext(ThemeContext));\n  // but it is based on a constant that will never change at runtime\n  // it's effectively like having two implementations and switching them out\n  // so it's not actually breaking anything\n\n\n  var sheetRef = React.useRef();\n  useInsertionEffectWithLayoutFallback(function () {\n    var key = cache.key + \"-global\"; // use case of https://github.com/emotion-js/emotion/issues/2675\n\n    var sheet = new cache.sheet.constructor({\n      key: key,\n      nonce: cache.sheet.nonce,\n      container: cache.sheet.container,\n      speedy: cache.sheet.isSpeedy\n    });\n    var rehydrating = false;\n    var node = document.querySelector(\"style[data-emotion=\\\"\" + key + \" \" + serialized.name + \"\\\"]\");\n\n    if (cache.sheet.tags.length) {\n      sheet.before = cache.sheet.tags[0];\n    }\n\n    if (node !== null) {\n      rehydrating = true; // clear the hash so this node won't be recognizable as rehydratable by other <Global/>s\n\n      node.setAttribute('data-emotion', key);\n      sheet.hydrate([node]);\n    }\n\n    sheetRef.current = [sheet, rehydrating];\n    return function () {\n      sheet.flush();\n    };\n  }, [cache]);\n  useInsertionEffectWithLayoutFallback(function () {\n    var sheetRefCurrent = sheetRef.current;\n    var sheet = sheetRefCurrent[0],\n        rehydrating = sheetRefCurrent[1];\n\n    if (rehydrating) {\n      sheetRefCurrent[1] = false;\n      return;\n    }\n\n    if (serialized.next !== undefined) {\n      // insert keyframes\n      insertStyles(cache, serialized.next, true);\n    }\n\n    if (sheet.tags.length) {\n      // if this doesn't exist then it will be null so the style element will be appended\n      var element = sheet.tags[sheet.tags.length - 1].nextElementSibling;\n      sheet.before = element;\n      sheet.flush();\n    }\n\n    cache.insert(\"\", serialized, sheet, false);\n  }, [cache, serialized.name]);\n  return null;\n});\n\nfunction css() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  return serializeStyles(args);\n}\n\nfunction keyframes() {\n  var insertable = css.apply(void 0, arguments);\n  var name = \"animation-\" + insertable.name;\n  return {\n    name: name,\n    styles: \"@keyframes \" + name + \"{\" + insertable.styles + \"}\",\n    anim: 1,\n    toString: function toString() {\n      return \"_EMO_\" + this.name + \"_\" + this.styles + \"_EMO_\";\n    }\n  };\n}\n\nvar classnames = function classnames(args) {\n  var len = args.length;\n  var i = 0;\n  var cls = '';\n\n  for (; i < len; i++) {\n    var arg = args[i];\n    if (arg == null) continue;\n    var toAdd = void 0;\n\n    switch (typeof arg) {\n      case 'boolean':\n        break;\n\n      case 'object':\n        {\n          if (Array.isArray(arg)) {\n            toAdd = classnames(arg);\n          } else {\n\n            toAdd = '';\n\n            for (var k in arg) {\n              if (arg[k] && k) {\n                toAdd && (toAdd += ' ');\n                toAdd += k;\n              }\n            }\n          }\n\n          break;\n        }\n\n      default:\n        {\n          toAdd = arg;\n        }\n    }\n\n    if (toAdd) {\n      cls && (cls += ' ');\n      cls += toAdd;\n    }\n  }\n\n  return cls;\n};\n\nfunction merge(registered, css, className) {\n  var registeredStyles = [];\n  var rawClassName = getRegisteredStyles(registered, registeredStyles, className);\n\n  if (registeredStyles.length < 2) {\n    return className;\n  }\n\n  return rawClassName + css(registeredStyles);\n}\n\nvar Insertion = function Insertion(_ref) {\n  var cache = _ref.cache,\n      serializedArr = _ref.serializedArr;\n  useInsertionEffectAlwaysWithSyncFallback(function () {\n\n    for (var i = 0; i < serializedArr.length; i++) {\n      insertStyles(cache, serializedArr[i], false);\n    }\n  });\n\n  return null;\n};\n\nvar ClassNames = /* #__PURE__ */withEmotionCache(function (props, cache) {\n  var hasRendered = false;\n  var serializedArr = [];\n\n  var css = function css() {\n    if (hasRendered && isDevelopment) {\n      throw new Error('css can only be used during render');\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    var serialized = serializeStyles(args, cache.registered);\n    serializedArr.push(serialized); // registration has to happen here as the result of this might get consumed by `cx`\n\n    registerStyles(cache, serialized, false);\n    return cache.key + \"-\" + serialized.name;\n  };\n\n  var cx = function cx() {\n    if (hasRendered && isDevelopment) {\n      throw new Error('cx can only be used during render');\n    }\n\n    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      args[_key2] = arguments[_key2];\n    }\n\n    return merge(cache.registered, css, classnames(args));\n  };\n\n  var content = {\n    css: css,\n    cx: cx,\n    theme: React.useContext(ThemeContext)\n  };\n  var ele = props.children(content);\n  hasRendered = true;\n  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {\n    cache: cache,\n    serializedArr: serializedArr\n  }), ele);\n});\n\nexport { ClassNames, Global, jsx as createElement, css, jsx, keyframes };\n","var unitlessKeys = {\n  animationIterationCount: 1,\n  aspectRatio: 1,\n  borderImageOutset: 1,\n  borderImageSlice: 1,\n  borderImageWidth: 1,\n  boxFlex: 1,\n  boxFlexGroup: 1,\n  boxOrdinalGroup: 1,\n  columnCount: 1,\n  columns: 1,\n  flex: 1,\n  flexGrow: 1,\n  flexPositive: 1,\n  flexShrink: 1,\n  flexNegative: 1,\n  flexOrder: 1,\n  gridRow: 1,\n  gridRowEnd: 1,\n  gridRowSpan: 1,\n  gridRowStart: 1,\n  gridColumn: 1,\n  gridColumnEnd: 1,\n  gridColumnSpan: 1,\n  gridColumnStart: 1,\n  msGridRow: 1,\n  msGridRowSpan: 1,\n  msGridColumn: 1,\n  msGridColumnSpan: 1,\n  fontWeight: 1,\n  lineHeight: 1,\n  opacity: 1,\n  order: 1,\n  orphans: 1,\n  scale: 1,\n  tabSize: 1,\n  widows: 1,\n  zIndex: 1,\n  zoom: 1,\n  WebkitLineClamp: 1,\n  // SVG-related properties\n  fillOpacity: 1,\n  floodOpacity: 1,\n  stopOpacity: 1,\n  strokeDasharray: 1,\n  strokeDashoffset: 1,\n  strokeMiterlimit: 1,\n  strokeOpacity: 1,\n  strokeWidth: 1\n};\n\nexport { unitlessKeys as default };\n","import hashString from '@emotion/hash';\nimport unitless from '@emotion/unitless';\nimport memoize from '@emotion/memoize';\n\nvar isDevelopment = false;\n\nvar hyphenateRegex = /[A-Z]|^ms/g;\nvar animationRegex = /_EMO_([^_]+?)_([^]*?)_EMO_/g;\n\nvar isCustomProperty = function isCustomProperty(property) {\n  return property.charCodeAt(1) === 45;\n};\n\nvar isProcessableValue = function isProcessableValue(value) {\n  return value != null && typeof value !== 'boolean';\n};\n\nvar processStyleName = /* #__PURE__ */memoize(function (styleName) {\n  return isCustomProperty(styleName) ? styleName : styleName.replace(hyphenateRegex, '-$&').toLowerCase();\n});\n\nvar processStyleValue = function processStyleValue(key, value) {\n  switch (key) {\n    case 'animation':\n    case 'animationName':\n      {\n        if (typeof value === 'string') {\n          return value.replace(animationRegex, function (match, p1, p2) {\n            cursor = {\n              name: p1,\n              styles: p2,\n              next: cursor\n            };\n            return p1;\n          });\n        }\n      }\n  }\n\n  if (unitless[key] !== 1 && !isCustomProperty(key) && typeof value === 'number' && value !== 0) {\n    return value + 'px';\n  }\n\n  return value;\n};\n\nvar noComponentSelectorMessage = 'Component selectors can only be used in conjunction with ' + '@emotion/babel-plugin, the swc Emotion plugin, or another Emotion-aware ' + 'compiler transform.';\n\nfunction handleInterpolation(mergedProps, registered, interpolation) {\n  if (interpolation == null) {\n    return '';\n  }\n\n  var componentSelector = interpolation;\n\n  if (componentSelector.__emotion_styles !== undefined) {\n\n    return componentSelector;\n  }\n\n  switch (typeof interpolation) {\n    case 'boolean':\n      {\n        return '';\n      }\n\n    case 'object':\n      {\n        var keyframes = interpolation;\n\n        if (keyframes.anim === 1) {\n          cursor = {\n            name: keyframes.name,\n            styles: keyframes.styles,\n            next: cursor\n          };\n          return keyframes.name;\n        }\n\n        var serializedStyles = interpolation;\n\n        if (serializedStyles.styles !== undefined) {\n          var next = serializedStyles.next;\n\n          if (next !== undefined) {\n            // not the most efficient thing ever but this is a pretty rare case\n            // and there will be very few iterations of this generally\n            while (next !== undefined) {\n              cursor = {\n                name: next.name,\n                styles: next.styles,\n                next: cursor\n              };\n              next = next.next;\n            }\n          }\n\n          var styles = serializedStyles.styles + \";\";\n          return styles;\n        }\n\n        return createStringFromObject(mergedProps, registered, interpolation);\n      }\n\n    case 'function':\n      {\n        if (mergedProps !== undefined) {\n          var previousCursor = cursor;\n          var result = interpolation(mergedProps);\n          cursor = previousCursor;\n          return handleInterpolation(mergedProps, registered, result);\n        }\n\n        break;\n      }\n  } // finalize string values (regular strings and functions interpolated into css calls)\n\n\n  var asString = interpolation;\n\n  if (registered == null) {\n    return asString;\n  }\n\n  var cached = registered[asString];\n  return cached !== undefined ? cached : asString;\n}\n\nfunction createStringFromObject(mergedProps, registered, obj) {\n  var string = '';\n\n  if (Array.isArray(obj)) {\n    for (var i = 0; i < obj.length; i++) {\n      string += handleInterpolation(mergedProps, registered, obj[i]) + \";\";\n    }\n  } else {\n    for (var key in obj) {\n      var value = obj[key];\n\n      if (typeof value !== 'object') {\n        var asString = value;\n\n        if (registered != null && registered[asString] !== undefined) {\n          string += key + \"{\" + registered[asString] + \"}\";\n        } else if (isProcessableValue(asString)) {\n          string += processStyleName(key) + \":\" + processStyleValue(key, asString) + \";\";\n        }\n      } else {\n        if (key === 'NO_COMPONENT_SELECTOR' && isDevelopment) {\n          throw new Error(noComponentSelectorMessage);\n        }\n\n        if (Array.isArray(value) && typeof value[0] === 'string' && (registered == null || registered[value[0]] === undefined)) {\n          for (var _i = 0; _i < value.length; _i++) {\n            if (isProcessableValue(value[_i])) {\n              string += processStyleName(key) + \":\" + processStyleValue(key, value[_i]) + \";\";\n            }\n          }\n        } else {\n          var interpolated = handleInterpolation(mergedProps, registered, value);\n\n          switch (key) {\n            case 'animation':\n            case 'animationName':\n              {\n                string += processStyleName(key) + \":\" + interpolated + \";\";\n                break;\n              }\n\n            default:\n              {\n\n                string += key + \"{\" + interpolated + \"}\";\n              }\n          }\n        }\n      }\n    }\n  }\n\n  return string;\n}\n\nvar labelPattern = /label:\\s*([^\\s;{]+)\\s*(;|$)/g; // this is the cursor for keyframes\n// keyframes are stored on the SerializedStyles object as a linked list\n\nvar cursor;\nfunction serializeStyles(args, registered, mergedProps) {\n  if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null && args[0].styles !== undefined) {\n    return args[0];\n  }\n\n  var stringMode = true;\n  var styles = '';\n  cursor = undefined;\n  var strings = args[0];\n\n  if (strings == null || strings.raw === undefined) {\n    stringMode = false;\n    styles += handleInterpolation(mergedProps, registered, strings);\n  } else {\n    var asTemplateStringsArr = strings;\n\n    styles += asTemplateStringsArr[0];\n  } // we start at 1 since we've already handled the first arg\n\n\n  for (var i = 1; i < args.length; i++) {\n    styles += handleInterpolation(mergedProps, registered, args[i]);\n\n    if (stringMode) {\n      var templateStringsArr = strings;\n\n      styles += templateStringsArr[i];\n    }\n  } // using a global regex with .exec is stateful so lastIndex has to be reset each time\n\n\n  labelPattern.lastIndex = 0;\n  var identifierName = '';\n  var match; // https://esbench.com/bench/5b809c2cf2949800a0f61fb5\n\n  while ((match = labelPattern.exec(styles)) !== null) {\n    identifierName += '-' + match[1];\n  }\n\n  var name = hashString(styles) + identifierName;\n\n  return {\n    name: name,\n    styles: styles,\n    next: cursor\n  };\n}\n\nexport { serializeStyles };\n","/* eslint-disable */\n// Inspired by https://github.com/garycourt/murmurhash-js\n// Ported from https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37-L86\nfunction murmur2(str) {\n  // 'm' and 'r' are mixing constants generated offline.\n  // They're not really 'magic', they just happen to work well.\n  // const m = 0x5bd1e995;\n  // const r = 24;\n  // Initialize the hash\n  var h = 0; // Mix 4 bytes at a time into the hash\n\n  var k,\n      i = 0,\n      len = str.length;\n\n  for (; len >= 4; ++i, len -= 4) {\n    k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;\n    k =\n    /* Math.imul(k, m): */\n    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16);\n    k ^=\n    /* k >>> r: */\n    k >>> 24;\n    h =\n    /* Math.imul(k, m): */\n    (k & 0xffff) * 0x5bd1e995 + ((k >>> 16) * 0xe995 << 16) ^\n    /* Math.imul(h, m): */\n    (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  } // Handle the last few bytes of the input array\n\n\n  switch (len) {\n    case 3:\n      h ^= (str.charCodeAt(i + 2) & 0xff) << 16;\n\n    case 2:\n      h ^= (str.charCodeAt(i + 1) & 0xff) << 8;\n\n    case 1:\n      h ^= str.charCodeAt(i) & 0xff;\n      h =\n      /* Math.imul(h, m): */\n      (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  } // Do a few final mixes of the hash to ensure the last few\n  // bytes are well-incorporated.\n\n\n  h ^= h >>> 13;\n  h =\n  /* Math.imul(h, m): */\n  (h & 0xffff) * 0x5bd1e995 + ((h >>> 16) * 0xe995 << 16);\n  return ((h ^ h >>> 15) >>> 0).toString(36);\n}\n\nexport { murmur2 as default };\n","import memoize from '@emotion/memoize';\n\n// eslint-disable-next-line no-undef\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|abbr|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|disableRemotePlayback|download|draggable|encType|enterKeyHint|fetchpriority|fetchPriority|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|translate|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|incremental|fallback|inert|itemProp|itemScope|itemType|itemID|itemRef|on|option|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar isPropValid = /* #__PURE__ */memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexport { isPropValid as default };\n","import _extends from '@babel/runtime/helpers/esm/extends';\nimport { withEmotionCache, ThemeContext } from '@emotion/react';\nimport { serializeStyles } from '@emotion/serialize';\nimport { useInsertionEffectAlwaysWithSyncFallback } from '@emotion/use-insertion-effect-with-fallbacks';\nimport { getRegisteredStyles, registerStyles, insertStyles } from '@emotion/utils';\nimport * as React from 'react';\nimport isPropValid from '@emotion/is-prop-valid';\n\nvar isDevelopment = false;\n\nvar testOmitPropsOnStringTag = isPropValid;\n\nvar testOmitPropsOnComponent = function testOmitPropsOnComponent(key) {\n  return key !== 'theme';\n};\n\nvar getDefaultShouldForwardProp = function getDefaultShouldForwardProp(tag) {\n  return typeof tag === 'string' && // 96 is one less than the char code\n  // for \"a\" so this is checking that\n  // it's a lowercase character\n  tag.charCodeAt(0) > 96 ? testOmitPropsOnStringTag : testOmitPropsOnComponent;\n};\nvar composeShouldForwardProps = function composeShouldForwardProps(tag, options, isReal) {\n  var shouldForwardProp;\n\n  if (options) {\n    var optionsShouldForwardProp = options.shouldForwardProp;\n    shouldForwardProp = tag.__emotion_forwardProp && optionsShouldForwardProp ? function (propName) {\n      return tag.__emotion_forwardProp(propName) && optionsShouldForwardProp(propName);\n    } : optionsShouldForwardProp;\n  }\n\n  if (typeof shouldForwardProp !== 'function' && isReal) {\n    shouldForwardProp = tag.__emotion_forwardProp;\n  }\n\n  return shouldForwardProp;\n};\n\nvar Insertion = function Insertion(_ref) {\n  var cache = _ref.cache,\n      serialized = _ref.serialized,\n      isStringTag = _ref.isStringTag;\n  registerStyles(cache, serialized, isStringTag);\n  useInsertionEffectAlwaysWithSyncFallback(function () {\n    return insertStyles(cache, serialized, isStringTag);\n  });\n\n  return null;\n};\n\nvar createStyled = function createStyled(tag, options) {\n\n  var isReal = tag.__emotion_real === tag;\n  var baseTag = isReal && tag.__emotion_base || tag;\n  var identifierName;\n  var targetClassName;\n\n  if (options !== undefined) {\n    identifierName = options.label;\n    targetClassName = options.target;\n  }\n\n  var shouldForwardProp = composeShouldForwardProps(tag, options, isReal);\n  var defaultShouldForwardProp = shouldForwardProp || getDefaultShouldForwardProp(baseTag);\n  var shouldUseAs = !defaultShouldForwardProp('as');\n  return function () {\n    // eslint-disable-next-line prefer-rest-params\n    var args = arguments;\n    var styles = isReal && tag.__emotion_styles !== undefined ? tag.__emotion_styles.slice(0) : [];\n\n    if (identifierName !== undefined) {\n      styles.push(\"label:\" + identifierName + \";\");\n    }\n\n    if (args[0] == null || args[0].raw === undefined) {\n      // eslint-disable-next-line prefer-spread\n      styles.push.apply(styles, args);\n    } else {\n      var templateStringsArr = args[0];\n\n      styles.push(templateStringsArr[0]);\n      var len = args.length;\n      var i = 1;\n\n      for (; i < len; i++) {\n\n        styles.push(args[i], templateStringsArr[i]);\n      }\n    }\n\n    var Styled = withEmotionCache(function (props, cache, ref) {\n      var FinalTag = shouldUseAs && props.as || baseTag;\n      var className = '';\n      var classInterpolations = [];\n      var mergedProps = props;\n\n      if (props.theme == null) {\n        mergedProps = {};\n\n        for (var key in props) {\n          mergedProps[key] = props[key];\n        }\n\n        mergedProps.theme = React.useContext(ThemeContext);\n      }\n\n      if (typeof props.className === 'string') {\n        className = getRegisteredStyles(cache.registered, classInterpolations, props.className);\n      } else if (props.className != null) {\n        className = props.className + \" \";\n      }\n\n      var serialized = serializeStyles(styles.concat(classInterpolations), cache.registered, mergedProps);\n      className += cache.key + \"-\" + serialized.name;\n\n      if (targetClassName !== undefined) {\n        className += \" \" + targetClassName;\n      }\n\n      var finalShouldForwardProp = shouldUseAs && shouldForwardProp === undefined ? getDefaultShouldForwardProp(FinalTag) : defaultShouldForwardProp;\n      var newProps = {};\n\n      for (var _key in props) {\n        if (shouldUseAs && _key === 'as') continue;\n\n        if (finalShouldForwardProp(_key)) {\n          newProps[_key] = props[_key];\n        }\n      }\n\n      newProps.className = className;\n\n      if (ref) {\n        newProps.ref = ref;\n      }\n\n      return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Insertion, {\n        cache: cache,\n        serialized: serialized,\n        isStringTag: typeof FinalTag === 'string'\n      }), /*#__PURE__*/React.createElement(FinalTag, newProps));\n    });\n    Styled.displayName = identifierName !== undefined ? identifierName : \"Styled(\" + (typeof baseTag === 'string' ? baseTag : baseTag.displayName || baseTag.name || 'Component') + \")\";\n    Styled.defaultProps = tag.defaultProps;\n    Styled.__emotion_real = Styled;\n    Styled.__emotion_base = baseTag;\n    Styled.__emotion_styles = styles;\n    Styled.__emotion_forwardProp = shouldForwardProp;\n    Object.defineProperty(Styled, 'toString', {\n      value: function value() {\n        if (targetClassName === undefined && isDevelopment) {\n          return 'NO_COMPONENT_SELECTOR';\n        }\n\n        return \".\" + targetClassName;\n      }\n    });\n\n    Styled.withComponent = function (nextTag, nextOptions) {\n      var newStyled = createStyled(nextTag, _extends({}, options, nextOptions, {\n        shouldForwardProp: composeShouldForwardProps(Styled, nextOptions, true)\n      }));\n      return newStyled.apply(void 0, styles);\n    };\n\n    return Styled;\n  };\n};\n\nexport { createStyled as default };\n","import createStyled from '../base/dist/emotion-styled-base.browser.esm.js';\nimport '@babel/runtime/helpers/extends';\nimport '@emotion/react';\nimport '@emotion/serialize';\nimport '@emotion/use-insertion-effect-with-fallbacks';\nimport '@emotion/utils';\nimport 'react';\nimport '@emotion/is-prop-valid';\n\nvar tags = ['a', 'abbr', 'address', 'area', 'article', 'aside', 'audio', 'b', 'base', 'bdi', 'bdo', 'big', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'cite', 'code', 'col', 'colgroup', 'data', 'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt', 'em', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'iframe', 'img', 'input', 'ins', 'kbd', 'keygen', 'label', 'legend', 'li', 'link', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meta', 'meter', 'nav', 'noscript', 'object', 'ol', 'optgroup', 'option', 'output', 'p', 'param', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'textarea', 'tfoot', 'th', 'thead', 'time', 'title', 'tr', 'track', 'u', 'ul', 'var', 'video', 'wbr', // SVG\n'circle', 'clipPath', 'defs', 'ellipse', 'foreignObject', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'svg', 'text', 'tspan'];\n\n// bind it to avoid mutating the original function\nvar newStyled = createStyled.bind(null);\ntags.forEach(function (tagName) {\n  newStyled[tagName] = newStyled(tagName);\n});\n\nexport { newStyled as default };\n","import * as React from 'react';\n\nvar syncFallback = function syncFallback(create) {\n  return create();\n};\n\nvar useInsertionEffect = React['useInsertion' + 'Effect'] ? React['useInsertion' + 'Effect'] : false;\nvar useInsertionEffectAlwaysWithSyncFallback = useInsertionEffect || syncFallback;\nvar useInsertionEffectWithLayoutFallback = useInsertionEffect || React.useLayoutEffect;\n\nexport { useInsertionEffectAlwaysWithSyncFallback, useInsertionEffectWithLayoutFallback };\n","var isBrowser = true;\n\nfunction getRegisteredStyles(registered, registeredStyles, classNames) {\n  var rawClassName = '';\n  classNames.split(' ').forEach(function (className) {\n    if (registered[className] !== undefined) {\n      registeredStyles.push(registered[className] + \";\");\n    } else if (className) {\n      rawClassName += className + \" \";\n    }\n  });\n  return rawClassName;\n}\nvar registerStyles = function registerStyles(cache, serialized, isStringTag) {\n  var className = cache.key + \"-\" + serialized.name;\n\n  if ( // we only need to add the styles to the registered cache if the\n  // class name could be used further down\n  // the tree but if it's a string tag, we know it won't\n  // so we don't have to add it to registered cache.\n  // this improves memory usage since we can avoid storing the whole style string\n  (isStringTag === false || // we need to always store it if we're in compat mode and\n  // in node since emotion-server relies on whether a style is in\n  // the registered cache to know whether a style is global or not\n  // also, note that this check will be dead code eliminated in the browser\n  isBrowser === false ) && cache.registered[className] === undefined) {\n    cache.registered[className] = serialized.styles;\n  }\n};\nvar insertStyles = function insertStyles(cache, serialized, isStringTag) {\n  registerStyles(cache, serialized, isStringTag);\n  var className = cache.key + \"-\" + serialized.name;\n\n  if (cache.inserted[serialized.name] === undefined) {\n    var current = serialized;\n\n    do {\n      cache.insert(serialized === current ? \".\" + className : '', current, cache.sheet, true);\n\n      current = current.next;\n    } while (current !== undefined);\n  }\n};\n\nexport { getRegisteredStyles, insertStyles, registerStyles };\n","var weakMemoize = function weakMemoize(func) {\n  var cache = new WeakMap();\n  return function (arg) {\n    if (cache.has(arg)) {\n      // Use non-null assertion because we just checked that the cache `has` it\n      // This allows us to remove `undefined` from the return value\n      return cache.get(arg);\n    }\n\n    var ret = func(arg);\n    cache.set(arg, ret);\n    return ret;\n  };\n};\n\nexport { weakMemoize as default };\n","import { EmblaPluginType } from 'embla-carousel'\n\nexport function isObject(subject: unknown): subject is Record<string, unknown> {\n  return Object.prototype.toString.call(subject) === '[object Object]'\n}\n\nexport function isRecord(\n  subject: unknown\n): subject is Record<string | number, unknown> {\n  return isObject(subject) || Array.isArray(subject)\n}\n\nexport function canUseDOM(): boolean {\n  return !!(\n    typeof window !== 'undefined' &&\n    window.document &&\n    window.document.createElement\n  )\n}\n\nexport function areOptionsEqual(\n  optionsA: Record<string, unknown>,\n  optionsB: Record<string, unknown>\n): boolean {\n  const optionsAKeys = Object.keys(optionsA)\n  const optionsBKeys = Object.keys(optionsB)\n\n  if (optionsAKeys.length !== optionsBKeys.length) return false\n\n  const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}))\n  const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}))\n\n  if (breakpointsA !== breakpointsB) return false\n\n  return optionsAKeys.every((key) => {\n    const valueA = optionsA[key]\n    const valueB = optionsB[key]\n    if (typeof valueA === 'function') return `${valueA}` === `${valueB}`\n    if (!isRecord(valueA) || !isRecord(valueB)) return valueA === valueB\n    return areOptionsEqual(valueA, valueB)\n  })\n}\n\nexport function sortAndMapPluginToOptions(\n  plugins: EmblaPluginType[]\n): EmblaPluginType['options'][] {\n  return plugins\n    .concat()\n    .sort((a, b) => (a.name > b.name ? 1 : -1))\n    .map((plugin) => plugin.options)\n}\n\nexport function arePluginsEqual(\n  pluginsA: EmblaPluginType[],\n  pluginsB: EmblaPluginType[]\n): boolean {\n  if (pluginsA.length !== pluginsB.length) return false\n\n  const optionsA = sortAndMapPluginToOptions(pluginsA)\n  const optionsB = sortAndMapPluginToOptions(pluginsB)\n\n  return optionsA.every((optionA, index) => {\n    const optionB = optionsB[index]\n    return areOptionsEqual(optionA, optionB)\n  })\n}\n","import { PointerEventType } from './DragTracker'\n\nexport type WindowType = Window & typeof globalThis\n\nexport function isNumber(subject: unknown): subject is number {\n  return typeof subject === 'number'\n}\n\nexport function isString(subject: unknown): subject is string {\n  return typeof subject === 'string'\n}\n\nexport function isBoolean(subject: unknown): subject is boolean {\n  return typeof subject === 'boolean'\n}\n\nexport function isObject(subject: unknown): subject is Record<string, unknown> {\n  return Object.prototype.toString.call(subject) === '[object Object]'\n}\n\nexport function mathAbs(n: number): number {\n  return Math.abs(n)\n}\n\nexport function mathSign(n: number): number {\n  return Math.sign(n)\n}\n\nexport function deltaAbs(valueB: number, valueA: number): number {\n  return mathAbs(valueB - valueA)\n}\n\nexport function factorAbs(valueB: number, valueA: number): number {\n  if (valueB === 0 || valueA === 0) return 0\n  if (mathAbs(valueB) <= mathAbs(valueA)) return 0\n  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA))\n  return mathAbs(diff / valueB)\n}\n\nexport function roundToTwoDecimals(num: number): number {\n  return Math.round(num * 100) / 100\n}\n\nexport function arrayKeys<Type>(array: Type[]): number[] {\n  return objectKeys(array).map(Number)\n}\n\nexport function arrayLast<Type>(array: Type[]): Type {\n  return array[arrayLastIndex(array)]\n}\n\nexport function arrayLastIndex<Type>(array: Type[]): number {\n  return Math.max(0, array.length - 1)\n}\n\nexport function arrayIsLastIndex<Type>(array: Type[], index: number): boolean {\n  return index === arrayLastIndex(array)\n}\n\nexport function arrayFromNumber(n: number, startAt: number = 0): number[] {\n  return Array.from(Array(n), (_, i) => startAt + i)\n}\n\nexport function objectKeys<Type extends object>(object: Type): string[] {\n  return Object.keys(object)\n}\n\nexport function objectsMergeDeep(\n  objectA: Record<string, unknown>,\n  objectB: Record<string, unknown>\n): Record<string, unknown> {\n  return [objectA, objectB].reduce((mergedObjects, currentObject) => {\n    objectKeys(currentObject).forEach((key) => {\n      const valueA = mergedObjects[key]\n      const valueB = currentObject[key]\n      const areObjects = isObject(valueA) && isObject(valueB)\n\n      mergedObjects[key] = areObjects\n        ? objectsMergeDeep(valueA, valueB)\n        : valueB\n    })\n    return mergedObjects\n  }, {})\n}\n\nexport function isMouseEvent(\n  evt: PointerEventType,\n  ownerWindow: WindowType\n): evt is MouseEvent {\n  return (\n    typeof ownerWindow.MouseEvent !== 'undefined' &&\n    evt instanceof ownerWindow.MouseEvent\n  )\n}\n","type EventNameType = keyof DocumentEventMap | keyof WindowEventMap\ntype EventHandlerType = (evt: any) => void\ntype EventOptionsType = boolean | AddEventListenerOptions | undefined\ntype EventRemoverType = () => void\n\nexport type EventStoreType = {\n  add: (\n    node: EventTarget,\n    type: EventNameType,\n    handler: EventHandlerType,\n    options?: EventOptionsType\n  ) => EventStoreType\n  clear: () => void\n}\n\nexport function EventStore(): EventStoreType {\n  let listeners: EventRemoverType[] = []\n\n  function add(\n    node: EventTarget,\n    type: EventNameType,\n    handler: EventHandlerType,\n    options: EventOptionsType = { passive: true }\n  ): EventStoreType {\n    let removeListener: EventRemoverType\n\n    if ('addEventListener' in node) {\n      node.addEventListener(type, handler, options)\n      removeListener = () => node.removeEventListener(type, handler, options)\n    } else {\n      const legacyMediaQueryList = <MediaQueryList>node\n      legacyMediaQueryList.addListener(handler)\n      removeListener = () => legacyMediaQueryList.removeListener(handler)\n    }\n\n    listeners.push(removeListener)\n    return self\n  }\n\n  function clear(): void {\n    listeners = listeners.filter((remove) => remove())\n  }\n\n  const self: EventStoreType = {\n    add,\n    clear\n  }\n  return self\n}\n","import { EngineType } from './Engine'\nimport { EventStore } from './EventStore'\nimport { WindowType } from './utils'\n\nexport type AnimationsUpdateType = (engine: EngineType) => void\nexport type AnimationsRenderType = (engine: EngineType, alpha: number) => void\n\nexport type AnimationsType = {\n  init: () => void\n  destroy: () => void\n  start: () => void\n  stop: () => void\n  update: () => void\n  render: (alpha: number) => void\n}\n\nexport function Animations(\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  update: () => void,\n  render: (alpha: number) => void\n): AnimationsType {\n  const documentVisibleHandler = EventStore()\n  const fixedTimeStep = 1000 / 60\n\n  let lastTimeStamp: number | null = null\n  let accumulatedTime = 0\n  let animationId = 0\n\n  function init(): void {\n    documentVisibleHandler.add(ownerDocument, 'visibilitychange', () => {\n      if (ownerDocument.hidden) reset()\n    })\n  }\n\n  function destroy(): void {\n    stop()\n    documentVisibleHandler.clear()\n  }\n\n  function animate(timeStamp: DOMHighResTimeStamp): void {\n    if (!animationId) return\n    if (!lastTimeStamp) {\n      lastTimeStamp = timeStamp\n      update()\n      update()\n    }\n\n    const timeElapsed = timeStamp - lastTimeStamp\n    lastTimeStamp = timeStamp\n    accumulatedTime += timeElapsed\n\n    while (accumulatedTime >= fixedTimeStep) {\n      update()\n      accumulatedTime -= fixedTimeStep\n    }\n\n    const alpha = accumulatedTime / fixedTimeStep\n    render(alpha)\n\n    if (animationId) {\n      animationId = ownerWindow.requestAnimationFrame(animate)\n    }\n  }\n\n  function start(): void {\n    if (animationId) return\n    animationId = ownerWindow.requestAnimationFrame(animate)\n  }\n\n  function stop(): void {\n    ownerWindow.cancelAnimationFrame(animationId)\n    lastTimeStamp = null\n    accumulatedTime = 0\n    animationId = 0\n  }\n\n  function reset(): void {\n    lastTimeStamp = null\n    accumulatedTime = 0\n  }\n\n  const self: AnimationsType = {\n    init,\n    destroy,\n    start,\n    stop,\n    update,\n    render\n  }\n  return self\n}\n","import { mathAbs } from './utils'\n\nexport type LimitType = {\n  min: number\n  max: number\n  length: number\n  constrain: (n: number) => number\n  reachedAny: (n: number) => boolean\n  reachedMax: (n: number) => boolean\n  reachedMin: (n: number) => boolean\n  removeOffset: (n: number) => number\n}\n\nexport function Limit(min: number = 0, max: number = 0): LimitType {\n  const length = mathAbs(min - max)\n\n  function reachedMin(n: number): boolean {\n    return n < min\n  }\n\n  function reachedMax(n: number): boolean {\n    return n > max\n  }\n\n  function reachedAny(n: number): boolean {\n    return reachedMin(n) || reachedMax(n)\n  }\n\n  function constrain(n: number): number {\n    if (!reachedAny(n)) return n\n    return reachedMin(n) ? min : max\n  }\n\n  function removeOffset(n: number): number {\n    if (!length) return n\n    return n - length * Math.ceil((n - max) / length)\n  }\n\n  const self: LimitType = {\n    length,\n    max,\n    min,\n    constrain,\n    reachedAny,\n    reachedMax,\n    reachedMin,\n    removeOffset\n  }\n  return self\n}\n","import { Limit } from './Limit'\nimport { mathAbs } from './utils'\n\nexport type CounterType = {\n  get: () => number\n  set: (n: number) => CounterType\n  add: (n: number) => CounterType\n  clone: () => CounterType\n}\n\nexport function Counter(\n  max: number,\n  start: number,\n  loop: boolean\n): CounterType {\n  const { constrain } = Limit(0, max)\n  const loopEnd = max + 1\n  let counter = withinLimit(start)\n\n  function withinLimit(n: number): number {\n    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd)\n  }\n\n  function get(): number {\n    return counter\n  }\n\n  function set(n: number): CounterType {\n    counter = withinLimit(n)\n    return self\n  }\n\n  function add(n: number): CounterType {\n    return clone().set(get() + n)\n  }\n\n  function clone(): CounterType {\n    return Counter(max, get(), loop)\n  }\n\n  const self: CounterType = {\n    get,\n    set,\n    add,\n    clone\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { AnimationsType } from './Animations'\nimport { CounterType } from './Counter'\nimport { DragTrackerType, PointerEventType } from './DragTracker'\nimport { EventHandlerType } from './EventHandler'\nimport { AxisType } from './Axis'\nimport { EventStore } from './EventStore'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollTargetType } from './ScrollTarget'\nimport { ScrollToType } from './ScrollTo'\nimport { Vector1DType } from './Vector1d'\nimport { PercentOfViewType } from './PercentOfView'\nimport { Limit } from './Limit'\nimport {\n  deltaAbs,\n  factorAbs,\n  isBoolean,\n  isMouseEvent,\n  mathAbs,\n  mathSign,\n  WindowType\n} from './utils'\n\ntype DragHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  evt: PointerEventType\n) => boolean | void\n\nexport type DragHandlerOptionType = boolean | DragHandlerCallbackType\n\nexport type DragHandlerType = {\n  init: (emblaApi: EmblaCarouselType) => void\n  destroy: () => void\n  pointerDown: () => boolean\n}\n\nexport function DragHandler(\n  axis: AxisType,\n  rootNode: HTMLElement,\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  target: Vector1DType,\n  dragTracker: DragTrackerType,\n  location: Vector1DType,\n  animation: AnimationsType,\n  scrollTo: ScrollToType,\n  scrollBody: ScrollBodyType,\n  scrollTarget: ScrollTargetType,\n  index: CounterType,\n  eventHandler: EventHandlerType,\n  percentOfView: PercentOfViewType,\n  dragFree: boolean,\n  dragThreshold: number,\n  skipSnaps: boolean,\n  baseFriction: number,\n  watchDrag: DragHandlerOptionType\n): DragHandlerType {\n  const { cross: crossAxis, direction } = axis\n  const focusNodes = ['INPUT', 'SELECT', 'TEXTAREA']\n  const nonPassiveEvent = { passive: false }\n  const initEvents = EventStore()\n  const dragEvents = EventStore()\n  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20))\n  const snapForceBoost = { mouse: 300, touch: 400 }\n  const freeForceBoost = { mouse: 500, touch: 600 }\n  const baseSpeed = dragFree ? 43 : 25\n\n  let isMoving = false\n  let startScroll = 0\n  let startCross = 0\n  let pointerIsDown = false\n  let preventScroll = false\n  let preventClick = false\n  let isMouse = false\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchDrag) return\n\n    function downIfAllowed(evt: PointerEventType): void {\n      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt)\n    }\n\n    const node = rootNode\n    initEvents\n      .add(node, 'dragstart', (evt) => evt.preventDefault(), nonPassiveEvent)\n      .add(node, 'touchmove', () => undefined, nonPassiveEvent)\n      .add(node, 'touchend', () => undefined)\n      .add(node, 'touchstart', downIfAllowed)\n      .add(node, 'mousedown', downIfAllowed)\n      .add(node, 'touchcancel', up)\n      .add(node, 'contextmenu', up)\n      .add(node, 'click', click, true)\n  }\n\n  function destroy(): void {\n    initEvents.clear()\n    dragEvents.clear()\n  }\n\n  function addDragEvents(): void {\n    const node = isMouse ? ownerDocument : rootNode\n    dragEvents\n      .add(node, 'touchmove', move, nonPassiveEvent)\n      .add(node, 'touchend', up)\n      .add(node, 'mousemove', move, nonPassiveEvent)\n      .add(node, 'mouseup', up)\n  }\n\n  function isFocusNode(node: Element): boolean {\n    const nodeName = node.nodeName || ''\n    return focusNodes.includes(nodeName)\n  }\n\n  function forceBoost(): number {\n    const boost = dragFree ? freeForceBoost : snapForceBoost\n    const type = isMouse ? 'mouse' : 'touch'\n    return boost[type]\n  }\n\n  function allowedForce(force: number, targetChanged: boolean): number {\n    const next = index.add(mathSign(force) * -1)\n    const baseForce = scrollTarget.byDistance(force, !dragFree).distance\n\n    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce\n    if (skipSnaps && targetChanged) return baseForce * 0.5\n\n    return scrollTarget.byIndex(next.get(), 0).distance\n  }\n\n  function down(evt: PointerEventType): void {\n    const isMouseEvt = isMouseEvent(evt, ownerWindow)\n    isMouse = isMouseEvt\n    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving\n    isMoving = deltaAbs(target.get(), location.get()) >= 2\n\n    if (isMouseEvt && evt.button !== 0) return\n    if (isFocusNode(evt.target as Element)) return\n\n    pointerIsDown = true\n    dragTracker.pointerDown(evt)\n    scrollBody.useFriction(0).useDuration(0)\n    target.set(location)\n    addDragEvents()\n    startScroll = dragTracker.readPoint(evt)\n    startCross = dragTracker.readPoint(evt, crossAxis)\n    eventHandler.emit('pointerDown')\n  }\n\n  function move(evt: PointerEventType): void {\n    const isTouchEvt = !isMouseEvent(evt, ownerWindow)\n    if (isTouchEvt && evt.touches.length >= 2) return up(evt)\n\n    const lastScroll = dragTracker.readPoint(evt)\n    const lastCross = dragTracker.readPoint(evt, crossAxis)\n    const diffScroll = deltaAbs(lastScroll, startScroll)\n    const diffCross = deltaAbs(lastCross, startCross)\n\n    if (!preventScroll && !isMouse) {\n      if (!evt.cancelable) return up(evt)\n      preventScroll = diffScroll > diffCross\n      if (!preventScroll) return up(evt)\n    }\n    const diff = dragTracker.pointerMove(evt)\n    if (diffScroll > dragThreshold) preventClick = true\n\n    scrollBody.useFriction(0.3).useDuration(0.75)\n    animation.start()\n    target.add(direction(diff))\n    evt.preventDefault()\n  }\n\n  function up(evt: PointerEventType): void {\n    const currentLocation = scrollTarget.byDistance(0, false)\n    const targetChanged = currentLocation.index !== index.get()\n    const rawForce = dragTracker.pointerUp(evt) * forceBoost()\n    const force = allowedForce(direction(rawForce), targetChanged)\n    const forceFactor = factorAbs(rawForce, force)\n    const speed = baseSpeed - 10 * forceFactor\n    const friction = baseFriction + forceFactor / 50\n\n    preventScroll = false\n    pointerIsDown = false\n    dragEvents.clear()\n    scrollBody.useDuration(speed).useFriction(friction)\n    scrollTo.distance(force, !dragFree)\n    isMouse = false\n    eventHandler.emit('pointerUp')\n  }\n\n  function click(evt: MouseEvent): void {\n    if (preventClick) {\n      evt.stopPropagation()\n      evt.preventDefault()\n      preventClick = false\n    }\n  }\n\n  function pointerDown(): boolean {\n    return pointerIsDown\n  }\n\n  const self: DragHandlerType = {\n    init,\n    destroy,\n    pointerDown\n  }\n  return self\n}\n","import { AxisOptionType, AxisType } from './Axis'\nimport { isMouseEvent, mathAbs, WindowType } from './utils'\n\ntype PointerCoordType = keyof Touch | keyof MouseEvent\nexport type PointerEventType = TouchEvent | MouseEvent\n\nexport type DragTrackerType = {\n  pointerDown: (evt: PointerEventType) => number\n  pointerMove: (evt: PointerEventType) => number\n  pointerUp: (evt: PointerEventType) => number\n  readPoint: (evt: PointerEventType, evtAxis?: AxisOptionType) => number\n}\n\nexport function DragTracker(\n  axis: AxisType,\n  ownerWindow: WindowType\n): DragTrackerType {\n  const logInterval = 170\n\n  let startEvent: PointerEventType\n  let lastEvent: PointerEventType\n\n  function readTime(evt: PointerEventType): number {\n    return evt.timeStamp\n  }\n\n  function readPoint(evt: PointerEventType, evtAxis?: AxisOptionType): number {\n    const property = evtAxis || axis.scroll\n    const coord: PointerCoordType = `client${property === 'x' ? 'X' : 'Y'}`\n    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord]\n  }\n\n  function pointerDown(evt: PointerEventType): number {\n    startEvent = evt\n    lastEvent = evt\n    return readPoint(evt)\n  }\n\n  function pointerMove(evt: PointerEventType): number {\n    const diff = readPoint(evt) - readPoint(lastEvent)\n    const expired = readTime(evt) - readTime(startEvent) > logInterval\n\n    lastEvent = evt\n    if (expired) startEvent = evt\n    return diff\n  }\n\n  function pointerUp(evt: PointerEventType): number {\n    if (!startEvent || !lastEvent) return 0\n    const diffDrag = readPoint(lastEvent) - readPoint(startEvent)\n    const diffTime = readTime(evt) - readTime(startEvent)\n    const expired = readTime(evt) - readTime(lastEvent) > logInterval\n    const force = diffDrag / diffTime\n    const isFlick = diffTime && !expired && mathAbs(force) > 0.1\n\n    return isFlick ? force : 0\n  }\n\n  const self: DragTrackerType = {\n    pointerDown,\n    pointerMove,\n    pointerUp,\n    readPoint\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { NodeRectsType } from './NodeRects'\nimport { isBoolean, mathAbs, WindowType } from './utils'\n\ntype ResizeHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  entries: ResizeObserverEntry[]\n) => boolean | void\n\nexport type ResizeHandlerOptionType = boolean | ResizeHandlerCallbackType\n\nexport type ResizeHandlerType = {\n  init: (emblaApi: EmblaCarouselType) => void\n  destroy: () => void\n}\n\nexport function ResizeHandler(\n  container: HTMLElement,\n  eventHandler: EventHandlerType,\n  ownerWindow: WindowType,\n  slides: HTMLElement[],\n  axis: AxisType,\n  watchResize: ResizeHandlerOptionType,\n  nodeRects: NodeRectsType\n): ResizeHandlerType {\n  const observeNodes = [container].concat(slides)\n  let resizeObserver: ResizeObserver\n  let containerSize: number\n  let slideSizes: number[] = []\n  let destroyed = false\n\n  function readSize(node: HTMLElement): number {\n    return axis.measureSize(nodeRects.measure(node))\n  }\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchResize) return\n\n    containerSize = readSize(container)\n    slideSizes = slides.map(readSize)\n\n    function defaultCallback(entries: ResizeObserverEntry[]): void {\n      for (const entry of entries) {\n        if (destroyed) return\n\n        const isContainer = entry.target === container\n        const slideIndex = slides.indexOf(<HTMLElement>entry.target)\n        const lastSize = isContainer ? containerSize : slideSizes[slideIndex]\n        const newSize = readSize(isContainer ? container : slides[slideIndex])\n        const diffSize = mathAbs(newSize - lastSize)\n\n        if (diffSize >= 0.5) {\n          emblaApi.reInit()\n          eventHandler.emit('resize')\n\n          break\n        }\n      }\n    }\n\n    resizeObserver = new ResizeObserver((entries) => {\n      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {\n        defaultCallback(entries)\n      }\n    })\n\n    ownerWindow.requestAnimationFrame(() => {\n      observeNodes.forEach((node) => resizeObserver.observe(node))\n    })\n  }\n\n  function destroy(): void {\n    destroyed = true\n    if (resizeObserver) resizeObserver.disconnect()\n  }\n\n  const self: ResizeHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { ScrollBodyType } from './ScrollBody'\nimport { Vector1DType } from './Vector1d'\nimport { mathAbs } from './utils'\nimport { PercentOfViewType } from './PercentOfView'\n\nexport type ScrollBoundsType = {\n  shouldConstrain: () => boolean\n  constrain: (pointerDown: boolean) => void\n  toggleActive: (active: boolean) => void\n}\n\nexport function ScrollBounds(\n  limit: LimitType,\n  location: Vector1DType,\n  target: Vector1DType,\n  scrollBody: ScrollBodyType,\n  percentOfView: PercentOfViewType\n): ScrollBoundsType {\n  const pullBackThreshold = percentOfView.measure(10)\n  const edgeOffsetTolerance = percentOfView.measure(50)\n  const frictionLimit = Limit(0.1, 0.99)\n  let disabled = false\n\n  function shouldConstrain(): boolean {\n    if (disabled) return false\n    if (!limit.reachedAny(target.get())) return false\n    if (!limit.reachedAny(location.get())) return false\n    return true\n  }\n\n  function constrain(pointerDown: boolean): void {\n    if (!shouldConstrain()) return\n    const edge = limit.reachedMin(location.get()) ? 'min' : 'max'\n    const diffToEdge = mathAbs(limit[edge] - location.get())\n    const diffToTarget = target.get() - location.get()\n    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance)\n\n    target.subtract(diffToTarget * friction)\n\n    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {\n      target.set(limit.constrain(target.get()))\n      scrollBody.useDuration(25).useBaseFriction()\n    }\n  }\n\n  function toggleActive(active: boolean): void {\n    disabled = !active\n  }\n\n  const self: ScrollBoundsType = {\n    shouldConstrain,\n    constrain,\n    toggleActive\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollLooperType = {\n  loop: (direction: number) => void\n}\n\nexport function ScrollLooper(\n  contentSize: number,\n  limit: LimitType,\n  location: Vector1DType,\n  vectors: Vector1DType[]\n): ScrollLooperType {\n  const jointSafety = 0.1\n  const min = limit.min + jointSafety\n  const max = limit.max + jointSafety\n  const { reachedMin, reachedMax } = Limit(min, max)\n\n  function shouldLoop(direction: number): boolean {\n    if (direction === 1) return reachedMax(location.get())\n    if (direction === -1) return reachedMin(location.get())\n    return false\n  }\n\n  function loop(direction: number): void {\n    if (!shouldLoop(direction)) return\n\n    const loopDistance = contentSize * (direction * -1)\n    vectors.forEach((v) => v.add(loopDistance))\n  }\n\n  const self: ScrollLooperType = {\n    loop\n  }\n  return self\n}\n","import { LimitType } from './Limit'\nimport { Vector1DType } from './Vector1d'\nimport { arrayLast, mathAbs, mathSign } from './utils'\n\nexport type TargetType = {\n  distance: number\n  index: number\n}\n\nexport type ScrollTargetType = {\n  byIndex: (target: number, direction: number) => TargetType\n  byDistance: (force: number, snap: boolean) => TargetType\n  shortcut: (target: number, direction: number) => number\n}\n\nexport function ScrollTarget(\n  loop: boolean,\n  scrollSnaps: number[],\n  contentSize: number,\n  limit: LimitType,\n  targetVector: Vector1DType\n): ScrollTargetType {\n  const { reachedAny, removeOffset, constrain } = limit\n\n  function minDistance(distances: number[]): number {\n    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0]\n  }\n\n  function findTargetSnap(target: number): TargetType {\n    const distance = loop ? removeOffset(target) : constrain(target)\n    const ascDiffsToSnaps = scrollSnaps\n      .map((snap, index) => ({ diff: shortcut(snap - distance, 0), index }))\n      .sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff))\n\n    const { index } = ascDiffsToSnaps[0]\n    return { index, distance }\n  }\n\n  function shortcut(target: number, direction: number): number {\n    const targets = [target, target + contentSize, target - contentSize]\n\n    if (!loop) return target\n    if (!direction) return minDistance(targets)\n\n    const matchingTargets = targets.filter((t) => mathSign(t) === direction)\n    if (matchingTargets.length) return minDistance(matchingTargets)\n    return arrayLast(targets) - contentSize\n  }\n\n  function byIndex(index: number, direction: number): TargetType {\n    const diffToSnap = scrollSnaps[index] - targetVector.get()\n    const distance = shortcut(diffToSnap, direction)\n    return { index, distance }\n  }\n\n  function byDistance(distance: number, snap: boolean): TargetType {\n    const target = targetVector.get() + distance\n    const { index, distance: targetSnapDistance } = findTargetSnap(target)\n    const reachedBound = !loop && reachedAny(target)\n\n    if (!snap || reachedBound) return { index, distance }\n\n    const diffToSnap = scrollSnaps[index] - targetSnapDistance\n    const snapDistance = distance + shortcut(diffToSnap, 0)\n\n    return { index, distance: snapDistance }\n  }\n\n  const self: ScrollTargetType = {\n    byDistance,\n    byIndex,\n    shortcut\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { EventStoreType } from './EventStore'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollToType } from './ScrollTo'\nimport { SlideRegistryType } from './SlideRegistry'\nimport { isBoolean, isNumber } from './utils'\n\ntype FocusHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  evt: FocusEvent\n) => boolean | void\n\nexport type FocusHandlerOptionType = boolean | FocusHandlerCallbackType\n\nexport type SlideFocusType = {\n  init: (emblaApi: EmblaCarouselType) => void\n}\n\nexport function SlideFocus(\n  root: HTMLElement,\n  slides: HTMLElement[],\n  slideRegistry: SlideRegistryType['slideRegistry'],\n  scrollTo: ScrollToType,\n  scrollBody: ScrollBodyType,\n  eventStore: EventStoreType,\n  eventHandler: EventHandlerType,\n  watchFocus: FocusHandlerOptionType\n): SlideFocusType {\n  const focusListenerOptions = { passive: true, capture: true }\n  let lastTabPressTime = 0\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchFocus) return\n\n    function defaultCallback(index: number): void {\n      const nowTime = new Date().getTime()\n      const diffTime = nowTime - lastTabPressTime\n\n      if (diffTime > 10) return\n\n      eventHandler.emit('slideFocusStart')\n      root.scrollLeft = 0\n\n      const group = slideRegistry.findIndex((group) => group.includes(index))\n\n      if (!isNumber(group)) return\n\n      scrollBody.useDuration(0)\n      scrollTo.index(group, 0)\n\n      eventHandler.emit('slideFocus')\n    }\n\n    eventStore.add(document, 'keydown', registerTabPress, false)\n\n    slides.forEach((slide, slideIndex) => {\n      eventStore.add(\n        slide,\n        'focus',\n        (evt: FocusEvent) => {\n          if (isBoolean(watchFocus) || watchFocus(emblaApi, evt)) {\n            defaultCallback(slideIndex)\n          }\n        },\n        focusListenerOptions\n      )\n    })\n  }\n\n  function registerTabPress(event: KeyboardEvent): void {\n    if (event.code === 'Tab') lastTabPressTime = new Date().getTime()\n  }\n\n  const self: SlideFocusType = {\n    init\n  }\n  return self\n}\n","import { isNumber } from './utils'\n\nexport type Vector1DType = {\n  get: () => number\n  set: (n: Vector1DType | number) => void\n  add: (n: Vector1DType | number) => void\n  subtract: (n: Vector1DType | number) => void\n}\n\nexport function Vector1D(initialValue: number): Vector1DType {\n  let value = initialValue\n\n  function get(): number {\n    return value\n  }\n\n  function set(n: Vector1DType | number): void {\n    value = normalizeInput(n)\n  }\n\n  function add(n: Vector1DType | number): void {\n    value += normalizeInput(n)\n  }\n\n  function subtract(n: Vector1DType | number): void {\n    value -= normalizeInput(n)\n  }\n\n  function normalizeInput(n: Vector1DType | number): number {\n    return isNumber(n) ? n : n.get()\n  }\n\n  const self: Vector1DType = {\n    get,\n    set,\n    add,\n    subtract\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { roundToTwoDecimals } from './utils'\n\nexport type TranslateType = {\n  clear: () => void\n  to: (target: number) => void\n  toggleActive: (active: boolean) => void\n}\n\nexport function Translate(\n  axis: AxisType,\n  container: HTMLElement\n): TranslateType {\n  const translate = axis.scroll === 'x' ? x : y\n  const containerStyle = container.style\n  let previousTarget: number | null = null\n  let disabled = false\n\n  function x(n: number): string {\n    return `translate3d(${n}px,0px,0px)`\n  }\n\n  function y(n: number): string {\n    return `translate3d(0px,${n}px,0px)`\n  }\n\n  function to(target: number): void {\n    if (disabled) return\n\n    const newTarget = roundToTwoDecimals(axis.direction(target))\n    if (newTarget === previousTarget) return\n\n    containerStyle.transform = translate(newTarget)\n    previousTarget = newTarget\n  }\n\n  function toggleActive(active: boolean): void {\n    disabled = !active\n  }\n\n  function clear(): void {\n    if (disabled) return\n    containerStyle.transform = ''\n    if (!container.getAttribute('style')) container.removeAttribute('style')\n  }\n\n  const self: TranslateType = {\n    clear,\n    to,\n    toggleActive\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { arrayKeys } from './utils'\nimport { Vector1D, Vector1DType } from './Vector1d'\nimport { Translate, TranslateType } from './Translate'\n\ntype SlideBoundType = {\n  start: number\n  end: number\n}\n\ntype LoopPointType = {\n  loopPoint: number\n  index: number\n  translate: TranslateType\n  slideLocation: Vector1DType\n  target: () => number\n}\n\nexport type SlideLooperType = {\n  canLoop: () => boolean\n  clear: () => void\n  loop: () => void\n  loopPoints: LoopPointType[]\n}\n\nexport function SlideLooper(\n  axis: AxisType,\n  viewSize: number,\n  contentSize: number,\n  slideSizes: number[],\n  slideSizesWithGaps: number[],\n  snaps: number[],\n  scrollSnaps: number[],\n  location: Vector1DType,\n  slides: HTMLElement[]\n): SlideLooperType {\n  const roundingSafety = 0.5\n  const ascItems = arrayKeys(slideSizesWithGaps)\n  const descItems = arrayKeys(slideSizesWithGaps).reverse()\n  const loopPoints = startPoints().concat(endPoints())\n\n  function removeSlideSizes(indexes: number[], from: number): number {\n    return indexes.reduce((a: number, i) => {\n      return a - slideSizesWithGaps[i]\n    }, from)\n  }\n\n  function slidesInGap(indexes: number[], gap: number): number[] {\n    return indexes.reduce((a: number[], i) => {\n      const remainingGap = removeSlideSizes(a, gap)\n      return remainingGap > 0 ? a.concat([i]) : a\n    }, [])\n  }\n\n  function findSlideBounds(offset: number): SlideBoundType[] {\n    return snaps.map((snap, index) => ({\n      start: snap - slideSizes[index] + roundingSafety + offset,\n      end: snap + viewSize - roundingSafety + offset\n    }))\n  }\n\n  function findLoopPoints(\n    indexes: number[],\n    offset: number,\n    isEndEdge: boolean\n  ): LoopPointType[] {\n    const slideBounds = findSlideBounds(offset)\n\n    return indexes.map((index) => {\n      const initial = isEndEdge ? 0 : -contentSize\n      const altered = isEndEdge ? contentSize : 0\n      const boundEdge = isEndEdge ? 'end' : 'start'\n      const loopPoint = slideBounds[index][boundEdge]\n\n      return {\n        index,\n        loopPoint,\n        slideLocation: Vector1D(-1),\n        translate: Translate(axis, slides[index]),\n        target: () => (location.get() > loopPoint ? initial : altered)\n      }\n    })\n  }\n\n  function startPoints(): LoopPointType[] {\n    const gap = scrollSnaps[0]\n    const indexes = slidesInGap(descItems, gap)\n    return findLoopPoints(indexes, contentSize, false)\n  }\n\n  function endPoints(): LoopPointType[] {\n    const gap = viewSize - scrollSnaps[0] - 1\n    const indexes = slidesInGap(ascItems, gap)\n    return findLoopPoints(indexes, -contentSize, true)\n  }\n\n  function canLoop(): boolean {\n    return loopPoints.every(({ index }) => {\n      const otherIndexes = ascItems.filter((i) => i !== index)\n      return removeSlideSizes(otherIndexes, viewSize) <= 0.1\n    })\n  }\n\n  function loop(): void {\n    loopPoints.forEach((loopPoint) => {\n      const { target, translate, slideLocation } = loopPoint\n      const shiftLocation = target()\n      if (shiftLocation === slideLocation.get()) return\n      translate.to(shiftLocation)\n      slideLocation.set(shiftLocation)\n    })\n  }\n\n  function clear(): void {\n    loopPoints.forEach((loopPoint) => loopPoint.translate.clear())\n  }\n\n  const self: SlideLooperType = {\n    canLoop,\n    clear,\n    loop,\n    loopPoints\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { EventHandlerType } from './EventHandler'\nimport { isBoolean } from './utils'\n\ntype SlidesHandlerCallbackType = (\n  emblaApi: EmblaCarouselType,\n  mutations: MutationRecord[]\n) => boolean | void\n\nexport type SlidesHandlerOptionType = boolean | SlidesHandlerCallbackType\n\nexport type SlidesHandlerType = {\n  init: (emblaApi: EmblaCarouselType) => void\n  destroy: () => void\n}\n\nexport function SlidesHandler(\n  container: HTMLElement,\n  eventHandler: EventHandlerType,\n  watchSlides: SlidesHandlerOptionType\n): SlidesHandlerType {\n  let mutationObserver: MutationObserver\n  let destroyed = false\n\n  function init(emblaApi: EmblaCarouselType): void {\n    if (!watchSlides) return\n\n    function defaultCallback(mutations: MutationRecord[]): void {\n      for (const mutation of mutations) {\n        if (mutation.type === 'childList') {\n          emblaApi.reInit()\n          eventHandler.emit('slidesChanged')\n          break\n        }\n      }\n    }\n\n    mutationObserver = new MutationObserver((mutations) => {\n      if (destroyed) return\n      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {\n        defaultCallback(mutations)\n      }\n    })\n\n    mutationObserver.observe(container, { childList: true })\n  }\n\n  function destroy(): void {\n    if (mutationObserver) mutationObserver.disconnect()\n    destroyed = true\n  }\n\n  const self: SlidesHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { EventHandlerType } from './EventHandler'\nimport { objectKeys } from './utils'\n\ntype IntersectionEntryMapType = {\n  [key: number]: IntersectionObserverEntry\n}\n\nexport type SlidesInViewOptionsType = IntersectionObserverInit['threshold']\n\nexport type SlidesInViewType = {\n  init: () => void\n  destroy: () => void\n  get: (inView?: boolean) => number[]\n}\n\nexport function SlidesInView(\n  container: HTMLElement,\n  slides: HTMLElement[],\n  eventHandler: EventHandlerType,\n  threshold: SlidesInViewOptionsType\n): SlidesInViewType {\n  const intersectionEntryMap: IntersectionEntryMapType = {}\n  let inViewCache: number[] | null = null\n  let notInViewCache: number[] | null = null\n  let intersectionObserver: IntersectionObserver\n  let destroyed = false\n\n  function init(): void {\n    intersectionObserver = new IntersectionObserver(\n      (entries) => {\n        if (destroyed) return\n\n        entries.forEach((entry) => {\n          const index = slides.indexOf(<HTMLElement>entry.target)\n          intersectionEntryMap[index] = entry\n        })\n\n        inViewCache = null\n        notInViewCache = null\n        eventHandler.emit('slidesInView')\n      },\n      {\n        root: container.parentElement,\n        threshold\n      }\n    )\n\n    slides.forEach((slide) => intersectionObserver.observe(slide))\n  }\n\n  function destroy(): void {\n    if (intersectionObserver) intersectionObserver.disconnect()\n    destroyed = true\n  }\n\n  function createInViewList(inView: boolean): number[] {\n    return objectKeys(intersectionEntryMap).reduce(\n      (list: number[], slideIndex) => {\n        const index = parseInt(slideIndex)\n        const { isIntersecting } = intersectionEntryMap[index]\n        const inViewMatch = inView && isIntersecting\n        const notInViewMatch = !inView && !isIntersecting\n\n        if (inViewMatch || notInViewMatch) list.push(index)\n        return list\n      },\n      []\n    )\n  }\n\n  function get(inView: boolean = true): number[] {\n    if (inView && inViewCache) return inViewCache\n    if (!inView && notInViewCache) return notInViewCache\n\n    const slideIndexes = createInViewList(inView)\n\n    if (inView) inViewCache = slideIndexes\n    if (!inView) notInViewCache = slideIndexes\n\n    return slideIndexes\n  }\n\n  const self: SlidesInViewType = {\n    init,\n    destroy,\n    get\n  }\n\n  return self\n}\n","import { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport {\n  arrayKeys,\n  arrayLast,\n  arrayLastIndex,\n  isNumber,\n  mathAbs\n} from './utils'\n\nexport type SlidesToScrollOptionType = 'auto' | number\n\nexport type SlidesToScrollType = {\n  groupSlides: <Type>(array: Type[]) => Type[][]\n}\n\nexport function SlidesToScroll(\n  axis: AxisType,\n  viewSize: number,\n  slidesToScroll: SlidesToScrollOptionType,\n  loop: boolean,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  startGap: number,\n  endGap: number,\n  pixelTolerance: number\n): SlidesToScrollType {\n  const { startEdge, endEdge, direction } = axis\n  const groupByNumber = isNumber(slidesToScroll)\n\n  function byNumber<Type>(array: Type[], groupSize: number): Type[][] {\n    return arrayKeys(array)\n      .filter((i) => i % groupSize === 0)\n      .map((i) => array.slice(i, i + groupSize))\n  }\n\n  function bySize<Type>(array: Type[]): Type[][] {\n    if (!array.length) return []\n\n    return arrayKeys(array)\n      .reduce((groups: number[], rectB, index) => {\n        const rectA = arrayLast(groups) || 0\n        const isFirst = rectA === 0\n        const isLast = rectB === arrayLastIndex(array)\n\n        const edgeA = containerRect[startEdge] - slideRects[rectA][startEdge]\n        const edgeB = containerRect[startEdge] - slideRects[rectB][endEdge]\n        const gapA = !loop && isFirst ? direction(startGap) : 0\n        const gapB = !loop && isLast ? direction(endGap) : 0\n        const chunkSize = mathAbs(edgeB - gapB - (edgeA + gapA))\n\n        if (index && chunkSize > viewSize + pixelTolerance) groups.push(rectB)\n        if (isLast) groups.push(array.length)\n        return groups\n      }, [])\n      .map((currentSize, index, groups) => {\n        const previousSize = Math.max(groups[index - 1] || 0)\n        return array.slice(previousSize, currentSize)\n      })\n  }\n\n  function groupSlides<Type>(array: Type[]): Type[][] {\n    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array)\n  }\n\n  const self: SlidesToScrollType = {\n    groupSlides\n  }\n  return self\n}\n","import { Alignment } from './Alignment'\nimport {\n  Animations,\n  AnimationsType,\n  AnimationsUpdateType,\n  AnimationsRenderType\n} from './Animations'\nimport { Axis, AxisType } from './Axis'\nimport { Counter, CounterType } from './Counter'\nimport { DragHandler, DragHandlerType } from './DragHandler'\nimport { DragTracker } from './DragTracker'\nimport { EventHandlerType } from './EventHandler'\nimport { EventStore, EventStoreType } from './EventStore'\nimport { LimitType } from './Limit'\nimport { NodeRectType, NodeRects } from './NodeRects'\nimport { OptionsType } from './Options'\nimport { PercentOfView, PercentOfViewType } from './PercentOfView'\nimport { ResizeHandler, ResizeHandlerType } from './ResizeHandler'\nimport { ScrollBody, ScrollBodyType } from './ScrollBody'\nimport { ScrollBounds, ScrollBoundsType } from './ScrollBounds'\nimport { ScrollContain } from './ScrollContain'\nimport { ScrollLimit } from './ScrollLimit'\nimport { ScrollLooper, ScrollLooperType } from './ScrollLooper'\nimport { ScrollProgress, ScrollProgressType } from './ScrollProgress'\nimport { ScrollSnaps } from './ScrollSnaps'\nimport { SlideRegistry, SlideRegistryType } from './SlideRegistry'\nimport { ScrollTarget, ScrollTargetType } from './ScrollTarget'\nimport { ScrollTo, ScrollToType } from './ScrollTo'\nimport { SlideFocus, SlideFocusType } from './SlideFocus'\nimport { SlideLooper, SlideLooperType } from './SlideLooper'\nimport { SlidesHandler, SlidesHandlerType } from './SlidesHandler'\nimport { SlidesInView, SlidesInViewType } from './SlidesInView'\nimport { SlideSizes } from './SlideSizes'\nimport { SlidesToScroll, SlidesToScrollType } from './SlidesToScroll'\nimport { Translate, TranslateType } from './Translate'\nimport { arrayKeys, arrayLast, arrayLastIndex, WindowType } from './utils'\nimport { Vector1D, Vector1DType } from './Vector1d'\n\nexport type EngineType = {\n  ownerDocument: Document\n  ownerWindow: WindowType\n  eventHandler: EventHandlerType\n  axis: AxisType\n  animation: AnimationsType\n  scrollBounds: ScrollBoundsType\n  scrollLooper: ScrollLooperType\n  scrollProgress: ScrollProgressType\n  index: CounterType\n  indexPrevious: CounterType\n  limit: LimitType\n  location: Vector1DType\n  offsetLocation: Vector1DType\n  previousLocation: Vector1DType\n  options: OptionsType\n  percentOfView: PercentOfViewType\n  scrollBody: ScrollBodyType\n  dragHandler: DragHandlerType\n  eventStore: EventStoreType\n  slideLooper: SlideLooperType\n  slidesInView: SlidesInViewType\n  slidesToScroll: SlidesToScrollType\n  target: Vector1DType\n  translate: TranslateType\n  resizeHandler: ResizeHandlerType\n  slidesHandler: SlidesHandlerType\n  scrollTo: ScrollToType\n  scrollTarget: ScrollTargetType\n  scrollSnapList: number[]\n  scrollSnaps: number[]\n  slideIndexes: number[]\n  slideFocus: SlideFocusType\n  slideRegistry: SlideRegistryType['slideRegistry']\n  containerRect: NodeRectType\n  slideRects: NodeRectType[]\n}\n\nexport function Engine(\n  root: HTMLElement,\n  container: HTMLElement,\n  slides: HTMLElement[],\n  ownerDocument: Document,\n  ownerWindow: WindowType,\n  options: OptionsType,\n  eventHandler: EventHandlerType\n): EngineType {\n  // Options\n  const {\n    align,\n    axis: scrollAxis,\n    direction,\n    startIndex,\n    loop,\n    duration,\n    dragFree,\n    dragThreshold,\n    inViewThreshold,\n    slidesToScroll: groupSlides,\n    skipSnaps,\n    containScroll,\n    watchResize,\n    watchSlides,\n    watchDrag,\n    watchFocus\n  } = options\n\n  // Measurements\n  const pixelTolerance = 2\n  const nodeRects = NodeRects()\n  const containerRect = nodeRects.measure(container)\n  const slideRects = slides.map(nodeRects.measure)\n  const axis = Axis(scrollAxis, direction)\n  const viewSize = axis.measureSize(containerRect)\n  const percentOfView = PercentOfView(viewSize)\n  const alignment = Alignment(align, viewSize)\n  const containSnaps = !loop && !!containScroll\n  const readEdgeGap = loop || !!containScroll\n  const { slideSizes, slideSizesWithGaps, startGap, endGap } = SlideSizes(\n    axis,\n    containerRect,\n    slideRects,\n    slides,\n    readEdgeGap,\n    ownerWindow\n  )\n  const slidesToScroll = SlidesToScroll(\n    axis,\n    viewSize,\n    groupSlides,\n    loop,\n    containerRect,\n    slideRects,\n    startGap,\n    endGap,\n    pixelTolerance\n  )\n  const { snaps, snapsAligned } = ScrollSnaps(\n    axis,\n    alignment,\n    containerRect,\n    slideRects,\n    slidesToScroll\n  )\n  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps)\n  const { snapsContained, scrollContainLimit } = ScrollContain(\n    viewSize,\n    contentSize,\n    snapsAligned,\n    containScroll,\n    pixelTolerance\n  )\n  const scrollSnaps = containSnaps ? snapsContained : snapsAligned\n  const { limit } = ScrollLimit(contentSize, scrollSnaps, loop)\n\n  // Indexes\n  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop)\n  const indexPrevious = index.clone()\n  const slideIndexes = arrayKeys(slides)\n\n  // Animation\n  const update: AnimationsUpdateType = ({\n    dragHandler,\n    scrollBody,\n    scrollBounds,\n    options: { loop }\n  }) => {\n    if (!loop) scrollBounds.constrain(dragHandler.pointerDown())\n    scrollBody.seek()\n  }\n\n  const render: AnimationsRenderType = (\n    {\n      scrollBody,\n      translate,\n      location,\n      offsetLocation,\n      previousLocation,\n      scrollLooper,\n      slideLooper,\n      dragHandler,\n      animation,\n      eventHandler,\n      scrollBounds,\n      options: { loop }\n    },\n    alpha\n  ) => {\n    const shouldSettle = scrollBody.settled()\n    const withinBounds = !scrollBounds.shouldConstrain()\n    const hasSettled = loop ? shouldSettle : shouldSettle && withinBounds\n\n    if (hasSettled && !dragHandler.pointerDown()) {\n      animation.stop()\n      eventHandler.emit('settle')\n    }\n    if (!hasSettled) eventHandler.emit('scroll')\n\n    const interpolatedLocation =\n      location.get() * alpha + previousLocation.get() * (1 - alpha)\n\n    offsetLocation.set(interpolatedLocation)\n\n    if (loop) {\n      scrollLooper.loop(scrollBody.direction())\n      slideLooper.loop()\n    }\n\n    translate.to(offsetLocation.get())\n  }\n\n  const animation = Animations(\n    ownerDocument,\n    ownerWindow,\n    () => update(engine),\n    (alpha: number) => render(engine, alpha)\n  )\n\n  // Shared\n  const friction = 0.68\n  const startLocation = scrollSnaps[index.get()]\n  const location = Vector1D(startLocation)\n  const previousLocation = Vector1D(startLocation)\n  const offsetLocation = Vector1D(startLocation)\n  const target = Vector1D(startLocation)\n  const scrollBody = ScrollBody(\n    location,\n    offsetLocation,\n    previousLocation,\n    target,\n    duration,\n    friction\n  )\n  const scrollTarget = ScrollTarget(\n    loop,\n    scrollSnaps,\n    contentSize,\n    limit,\n    target\n  )\n  const scrollTo = ScrollTo(\n    animation,\n    index,\n    indexPrevious,\n    scrollBody,\n    scrollTarget,\n    target,\n    eventHandler\n  )\n  const scrollProgress = ScrollProgress(limit)\n  const eventStore = EventStore()\n  const slidesInView = SlidesInView(\n    container,\n    slides,\n    eventHandler,\n    inViewThreshold\n  )\n  const { slideRegistry } = SlideRegistry(\n    containSnaps,\n    containScroll,\n    scrollSnaps,\n    scrollContainLimit,\n    slidesToScroll,\n    slideIndexes\n  )\n  const slideFocus = SlideFocus(\n    root,\n    slides,\n    slideRegistry,\n    scrollTo,\n    scrollBody,\n    eventStore,\n    eventHandler,\n    watchFocus\n  )\n\n  // Engine\n  const engine: EngineType = {\n    ownerDocument,\n    ownerWindow,\n    eventHandler,\n    containerRect,\n    slideRects,\n    animation,\n    axis,\n    dragHandler: DragHandler(\n      axis,\n      root,\n      ownerDocument,\n      ownerWindow,\n      target,\n      DragTracker(axis, ownerWindow),\n      location,\n      animation,\n      scrollTo,\n      scrollBody,\n      scrollTarget,\n      index,\n      eventHandler,\n      percentOfView,\n      dragFree,\n      dragThreshold,\n      skipSnaps,\n      friction,\n      watchDrag\n    ),\n    eventStore,\n    percentOfView,\n    index,\n    indexPrevious,\n    limit,\n    location,\n    offsetLocation,\n    previousLocation,\n    options,\n    resizeHandler: ResizeHandler(\n      container,\n      eventHandler,\n      ownerWindow,\n      slides,\n      axis,\n      watchResize,\n      nodeRects\n    ),\n    scrollBody,\n    scrollBounds: ScrollBounds(\n      limit,\n      offsetLocation,\n      target,\n      scrollBody,\n      percentOfView\n    ),\n    scrollLooper: ScrollLooper(contentSize, limit, offsetLocation, [\n      location,\n      offsetLocation,\n      previousLocation,\n      target\n    ]),\n    scrollProgress,\n    scrollSnapList: scrollSnaps.map(scrollProgress.get),\n    scrollSnaps,\n    scrollTarget,\n    scrollTo,\n    slideLooper: SlideLooper(\n      axis,\n      viewSize,\n      contentSize,\n      slideSizes,\n      slideSizesWithGaps,\n      snaps,\n      scrollSnaps,\n      offsetLocation,\n      slides\n    ),\n    slideFocus,\n    slidesHandler: SlidesHandler(container, eventHandler, watchSlides),\n    slidesInView,\n    slideIndexes,\n    slideRegistry,\n    slidesToScroll,\n    target,\n    translate: Translate(axis, container)\n  }\n\n  return engine\n}\n","export type NodeRectType = {\n  top: number\n  right: number\n  bottom: number\n  left: number\n  width: number\n  height: number\n}\n\nexport type NodeRectsType = {\n  measure: (node: HTMLElement) => NodeRectType\n}\n\nexport function NodeRects(): NodeRectsType {\n  function measure(node: HTMLElement): NodeRectType {\n    const { offsetTop, offsetLeft, offsetWidth, offsetHeight } = node\n    const offset: NodeRectType = {\n      top: offsetTop,\n      right: offsetLeft + offsetWidth,\n      bottom: offsetTop + offsetHeight,\n      left: offsetLeft,\n      width: offsetWidth,\n      height: offsetHeight\n    }\n\n    return offset\n  }\n\n  const self: NodeRectsType = {\n    measure\n  }\n  return self\n}\n","import { NodeRectType } from './NodeRects'\n\nexport type AxisOptionType = 'x' | 'y'\nexport type AxisDirectionOptionType = 'ltr' | 'rtl'\ntype AxisEdgeType = 'top' | 'right' | 'bottom' | 'left'\n\nexport type AxisType = {\n  scroll: AxisOptionType\n  cross: AxisOptionType\n  startEdge: AxisEdgeType\n  endEdge: AxisEdgeType\n  measureSize: (nodeRect: NodeRectType) => number\n  direction: (n: number) => number\n}\n\nexport function Axis(\n  axis: AxisOptionType,\n  contentDirection: AxisDirectionOptionType\n): AxisType {\n  const isRightToLeft = contentDirection === 'rtl'\n  const isVertical = axis === 'y'\n  const scroll = isVertical ? 'y' : 'x'\n  const cross = isVertical ? 'x' : 'y'\n  const sign = !isVertical && isRightToLeft ? -1 : 1\n  const startEdge = getStartEdge()\n  const endEdge = getEndEdge()\n\n  function measureSize(nodeRect: NodeRectType): number {\n    const { height, width } = nodeRect\n    return isVertical ? height : width\n  }\n\n  function getStartEdge(): AxisEdgeType {\n    if (isVertical) return 'top'\n    return isRightToLeft ? 'right' : 'left'\n  }\n\n  function getEndEdge(): AxisEdgeType {\n    if (isVertical) return 'bottom'\n    return isRightToLeft ? 'left' : 'right'\n  }\n\n  function direction(n: number): number {\n    return n * sign\n  }\n\n  const self: AxisType = {\n    scroll,\n    cross,\n    startEdge,\n    endEdge,\n    measureSize,\n    direction\n  }\n  return self\n}\n","export type PercentOfViewType = {\n  measure: (n: number) => number\n}\n\nexport function PercentOfView(viewSize: number): PercentOfViewType {\n  function measure(n: number): number {\n    return viewSize * (n / 100)\n  }\n\n  const self: PercentOfViewType = {\n    measure\n  }\n  return self\n}\n","import { isString } from './utils'\n\nexport type AlignmentOptionType =\n  | 'start'\n  | 'center'\n  | 'end'\n  | ((viewSize: number, snapSize: number, index: number) => number)\n\nexport type AlignmentType = {\n  measure: (n: number, index: number) => number\n}\n\nexport function Alignment(\n  align: AlignmentOptionType,\n  viewSize: number\n): AlignmentType {\n  const predefined = { start, center, end }\n\n  function start(): number {\n    return 0\n  }\n\n  function center(n: number): number {\n    return end(n) / 2\n  }\n\n  function end(n: number): number {\n    return viewSize - n\n  }\n\n  function measure(n: number, index: number): number {\n    if (isString(align)) return predefined[align](n)\n    return align(viewSize, n, index)\n  }\n\n  const self: AlignmentType = {\n    measure\n  }\n  return self\n}\n","import { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport { arrayIsLastIndex, arrayLast, mathAbs, WindowType } from './utils'\n\nexport type SlideSizesType = {\n  slideSizes: number[]\n  slideSizesWithGaps: number[]\n  startGap: number\n  endGap: number\n}\n\nexport function SlideSizes(\n  axis: AxisType,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  slides: HTMLElement[],\n  readEdgeGap: boolean,\n  ownerWindow: WindowType\n): SlideSizesType {\n  const { measureSize, startEdge, endEdge } = axis\n  const withEdgeGap = slideRects[0] && readEdgeGap\n  const startGap = measureStartGap()\n  const endGap = measureEndGap()\n  const slideSizes = slideRects.map(measureSize)\n  const slideSizesWithGaps = measureWithGaps()\n\n  function measureStartGap(): number {\n    if (!withEdgeGap) return 0\n    const slideRect = slideRects[0]\n    return mathAbs(containerRect[startEdge] - slideRect[startEdge])\n  }\n\n  function measureEndGap(): number {\n    if (!withEdgeGap) return 0\n    const style = ownerWindow.getComputedStyle(arrayLast(slides))\n    return parseFloat(style.getPropertyValue(`margin-${endEdge}`))\n  }\n\n  function measureWithGaps(): number[] {\n    return slideRects\n      .map((rect, index, rects) => {\n        const isFirst = !index\n        const isLast = arrayIsLastIndex(rects, index)\n        if (isFirst) return slideSizes[index] + startGap\n        if (isLast) return slideSizes[index] + endGap\n        return rects[index + 1][startEdge] - rect[startEdge]\n      })\n      .map(mathAbs)\n  }\n\n  const self: SlideSizesType = {\n    slideSizes,\n    slideSizesWithGaps,\n    startGap,\n    endGap\n  }\n  return self\n}\n","import { AlignmentType } from './Alignment'\nimport { AxisType } from './Axis'\nimport { NodeRectType } from './NodeRects'\nimport { SlidesToScrollType } from './SlidesToScroll'\nimport { arrayLast, mathAbs } from './utils'\n\nexport type ScrollSnapsType = {\n  snaps: number[]\n  snapsAligned: number[]\n}\n\nexport function ScrollSnaps(\n  axis: AxisType,\n  alignment: AlignmentType,\n  containerRect: NodeRectType,\n  slideRects: NodeRectType[],\n  slidesToScroll: SlidesToScrollType\n): ScrollSnapsType {\n  const { startEdge, endEdge } = axis\n  const { groupSlides } = slidesToScroll\n  const alignments = measureSizes().map(alignment.measure)\n  const snaps = measureUnaligned()\n  const snapsAligned = measureAligned()\n\n  function measureSizes(): number[] {\n    return groupSlides(slideRects)\n      .map((rects) => arrayLast(rects)[endEdge] - rects[0][startEdge])\n      .map(mathAbs)\n  }\n\n  function measureUnaligned(): number[] {\n    return slideRects\n      .map((rect) => containerRect[startEdge] - rect[startEdge])\n      .map((snap) => -mathAbs(snap))\n  }\n\n  function measureAligned(): number[] {\n    return groupSlides(snaps)\n      .map((g) => g[0])\n      .map((snap, index) => snap + alignments[index])\n  }\n\n  const self: ScrollSnapsType = {\n    snaps,\n    snapsAligned\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { arrayIsLastIndex, arrayLast, deltaAbs } from './utils'\n\nexport type ScrollContainOptionType = false | 'trimSnaps' | 'keepSnaps'\n\nexport type ScrollContainType = {\n  snapsContained: number[]\n  scrollContainLimit: LimitType\n}\n\nexport function ScrollContain(\n  viewSize: number,\n  contentSize: number,\n  snapsAligned: number[],\n  containScroll: ScrollContainOptionType,\n  pixelTolerance: number\n): ScrollContainType {\n  const scrollBounds = Limit(-contentSize + viewSize, 0)\n  const snapsBounded = measureBounded()\n  const scrollContainLimit = findScrollContainLimit()\n  const snapsContained = measureContained()\n\n  function usePixelTolerance(bound: number, snap: number): boolean {\n    return deltaAbs(bound, snap) <= 1\n  }\n\n  function findScrollContainLimit(): LimitType {\n    const startSnap = snapsBounded[0]\n    const endSnap = arrayLast(snapsBounded)\n    const min = snapsBounded.lastIndexOf(startSnap)\n    const max = snapsBounded.indexOf(endSnap) + 1\n    return Limit(min, max)\n  }\n\n  function measureBounded(): number[] {\n    return snapsAligned\n      .map((snapAligned, index) => {\n        const { min, max } = scrollBounds\n        const snap = scrollBounds.constrain(snapAligned)\n        const isFirst = !index\n        const isLast = arrayIsLastIndex(snapsAligned, index)\n        if (isFirst) return max\n        if (isLast) return min\n        if (usePixelTolerance(min, snap)) return min\n        if (usePixelTolerance(max, snap)) return max\n        return snap\n      })\n      .map((scrollBound) => parseFloat(scrollBound.toFixed(3)))\n  }\n\n  function measureContained(): number[] {\n    if (contentSize <= viewSize + pixelTolerance) return [scrollBounds.max]\n    if (containScroll === 'keepSnaps') return snapsBounded\n    const { min, max } = scrollContainLimit\n    return snapsBounded.slice(min, max)\n  }\n\n  const self: ScrollContainType = {\n    snapsContained,\n    scrollContainLimit\n  }\n  return self\n}\n","import { Limit, LimitType } from './Limit'\nimport { arrayLast } from './utils'\n\nexport type ScrollLimitType = {\n  limit: LimitType\n}\n\nexport function ScrollLimit(\n  contentSize: number,\n  scrollSnaps: number[],\n  loop: boolean\n): ScrollLimitType {\n  const max = scrollSnaps[0]\n  const min = loop ? max - contentSize : arrayLast(scrollSnaps)\n  const limit = Limit(min, max)\n\n  const self: ScrollLimitType = {\n    limit\n  }\n  return self\n}\n","import { mathSign, mathAbs } from './utils'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollBodyType = {\n  direction: () => number\n  duration: () => number\n  velocity: () => number\n  seek: () => ScrollBodyType\n  settled: () => boolean\n  useBaseFriction: () => ScrollBodyType\n  useBaseDuration: () => ScrollBodyType\n  useFriction: (n: number) => ScrollBodyType\n  useDuration: (n: number) => ScrollBodyType\n}\n\nexport function ScrollBody(\n  location: Vector1DType,\n  offsetLocation: Vector1DType,\n  previousLocation: Vector1DType,\n  target: Vector1DType,\n  baseDuration: number,\n  baseFriction: number\n): ScrollBodyType {\n  let scrollVelocity = 0\n  let scrollDirection = 0\n  let scrollDuration = baseDuration\n  let scrollFriction = baseFriction\n  let rawLocation = location.get()\n  let rawLocationPrevious = 0\n\n  function seek(): ScrollBodyType {\n    const displacement = target.get() - location.get()\n    const isInstant = !scrollDuration\n    let scrollDistance = 0\n\n    if (isInstant) {\n      scrollVelocity = 0\n      previousLocation.set(target)\n      location.set(target)\n\n      scrollDistance = displacement\n    } else {\n      previousLocation.set(location)\n\n      scrollVelocity += displacement / scrollDuration\n      scrollVelocity *= scrollFriction\n      rawLocation += scrollVelocity\n      location.add(scrollVelocity)\n\n      scrollDistance = rawLocation - rawLocationPrevious\n    }\n\n    scrollDirection = mathSign(scrollDistance)\n    rawLocationPrevious = rawLocation\n    return self\n  }\n\n  function settled(): boolean {\n    const diff = target.get() - offsetLocation.get()\n    return mathAbs(diff) < 0.001\n  }\n\n  function duration(): number {\n    return scrollDuration\n  }\n\n  function direction(): number {\n    return scrollDirection\n  }\n\n  function velocity(): number {\n    return scrollVelocity\n  }\n\n  function useBaseDuration(): ScrollBodyType {\n    return useDuration(baseDuration)\n  }\n\n  function useBaseFriction(): ScrollBodyType {\n    return useFriction(baseFriction)\n  }\n\n  function useDuration(n: number): ScrollBodyType {\n    scrollDuration = n\n    return self\n  }\n\n  function useFriction(n: number): ScrollBodyType {\n    scrollFriction = n\n    return self\n  }\n\n  const self: ScrollBodyType = {\n    direction,\n    duration,\n    velocity,\n    seek,\n    settled,\n    useBaseFriction,\n    useBaseDuration,\n    useFriction,\n    useDuration\n  }\n  return self\n}\n","import { AnimationsType } from './Animations'\nimport { CounterType } from './Counter'\nimport { EventHandlerType } from './EventHandler'\nimport { ScrollBodyType } from './ScrollBody'\nimport { ScrollTargetType, TargetType } from './ScrollTarget'\nimport { Vector1DType } from './Vector1d'\n\nexport type ScrollToType = {\n  distance: (n: number, snap: boolean) => void\n  index: (n: number, direction: number) => void\n}\n\nexport function ScrollTo(\n  animation: AnimationsType,\n  indexCurrent: CounterType,\n  indexPrevious: CounterType,\n  scrollBody: ScrollBodyType,\n  scrollTarget: ScrollTargetType,\n  targetVector: Vector1DType,\n  eventHandler: EventHandlerType\n): ScrollToType {\n  function scrollTo(target: TargetType): void {\n    const distanceDiff = target.distance\n    const indexDiff = target.index !== indexCurrent.get()\n\n    targetVector.add(distanceDiff)\n\n    if (distanceDiff) {\n      if (scrollBody.duration()) {\n        animation.start()\n      } else {\n        animation.update()\n        animation.render(1)\n        animation.update()\n      }\n    }\n\n    if (indexDiff) {\n      indexPrevious.set(indexCurrent.get())\n      indexCurrent.set(target.index)\n      eventHandler.emit('select')\n    }\n  }\n\n  function distance(n: number, snap: boolean): void {\n    const target = scrollTarget.byDistance(n, snap)\n    scrollTo(target)\n  }\n\n  function index(n: number, direction: number): void {\n    const targetIndex = indexCurrent.clone().set(n)\n    const target = scrollTarget.byIndex(targetIndex.get(), direction)\n    scrollTo(target)\n  }\n\n  const self: ScrollToType = {\n    distance,\n    index\n  }\n  return self\n}\n","import { LimitType } from './Limit'\n\nexport type ScrollProgressType = {\n  get: (n: number) => number\n}\n\nexport function ScrollProgress(limit: LimitType): ScrollProgressType {\n  const { max, length } = limit\n\n  function get(n: number): number {\n    const currentLocation = n - max\n    return length ? currentLocation / -length : 0\n  }\n\n  const self: ScrollProgressType = {\n    get\n  }\n  return self\n}\n","import { LimitType } from './Limit'\nimport { ScrollContainOptionType } from './ScrollContain'\nimport { SlidesToScrollType } from './SlidesToScroll'\nimport {\n  arrayFromNumber,\n  arrayIsLastIndex,\n  arrayLast,\n  arrayLastIndex\n} from './utils'\n\nexport type SlideRegistryType = {\n  slideRegistry: number[][]\n}\n\nexport function SlideRegistry(\n  containSnaps: boolean,\n  containScroll: ScrollContainOptionType,\n  scrollSnaps: number[],\n  scrollContainLimit: LimitType,\n  slidesToScroll: SlidesToScrollType,\n  slideIndexes: number[]\n): SlideRegistryType {\n  const { groupSlides } = slidesToScroll\n  const { min, max } = scrollContainLimit\n  const slideRegistry = createSlideRegistry()\n\n  function createSlideRegistry(): number[][] {\n    const groupedSlideIndexes = groupSlides(slideIndexes)\n    const doNotContain = !containSnaps || containScroll === 'keepSnaps'\n\n    if (scrollSnaps.length === 1) return [slideIndexes]\n    if (doNotContain) return groupedSlideIndexes\n\n    return groupedSlideIndexes.slice(min, max).map((group, index, groups) => {\n      const isFirst = !index\n      const isLast = arrayIsLastIndex(groups, index)\n\n      if (isFirst) {\n        const range = arrayLast(groups[0]) + 1\n        return arrayFromNumber(range)\n      }\n      if (isLast) {\n        const range = arrayLastIndex(slideIndexes) - arrayLast(groups)[0] + 1\n        return arrayFromNumber(range, arrayLast(groups)[0])\n      }\n      return group\n    })\n  }\n\n  const self: SlideRegistryType = {\n    slideRegistry\n  }\n  return self\n}\n","import { AlignmentOptionType } from './Alignment'\nimport { AxisDirectionOptionType, AxisOptionType } from './Axis'\nimport { SlidesToScrollOptionType } from './SlidesToScroll'\nimport { ScrollContainOptionType } from './ScrollContain'\nimport { DragHandlerOptionType } from './DragHandler'\nimport { ResizeHandlerOptionType } from './ResizeHandler'\nimport { SlidesHandlerOptionType } from './SlidesHandler'\nimport { SlidesInViewOptionsType } from './SlidesInView'\nimport { FocusHandlerOptionType } from './SlideFocus'\n\nexport type LooseOptionsType = {\n  [key: string]: unknown\n}\n\nexport type CreateOptionsType<Type extends LooseOptionsType> = Type & {\n  active: boolean\n  breakpoints: {\n    [key: string]: Omit<Partial<CreateOptionsType<Type>>, 'breakpoints'>\n  }\n}\n\nexport type OptionsType = CreateOptionsType<{\n  align: AlignmentOptionType\n  axis: AxisOptionType\n  container: string | HTMLElement | null\n  slides: string | HTMLElement[] | NodeListOf<HTMLElement> | null\n  containScroll: ScrollContainOptionType\n  direction: AxisDirectionOptionType\n  slidesToScroll: SlidesToScrollOptionType\n  dragFree: boolean\n  dragThreshold: number\n  inViewThreshold: SlidesInViewOptionsType\n  loop: boolean\n  skipSnaps: boolean\n  duration: number\n  startIndex: number\n  watchDrag: DragHandlerOptionType\n  watchResize: ResizeHandlerOptionType\n  watchSlides: SlidesHandlerOptionType\n  watchFocus: FocusHandlerOptionType\n}>\n\nexport const defaultOptions: OptionsType = {\n  align: 'center',\n  axis: 'x',\n  container: null,\n  slides: null,\n  containScroll: 'trimSnaps',\n  direction: 'ltr',\n  slidesToScroll: 1,\n  inViewThreshold: 0,\n  breakpoints: {},\n  dragFree: false,\n  dragThreshold: 10,\n  loop: false,\n  skipSnaps: false,\n  duration: 25,\n  startIndex: 0,\n  active: true,\n  watchDrag: true,\n  watchResize: true,\n  watchSlides: true,\n  watchFocus: true\n}\n\nexport type EmblaOptionsType = Partial<OptionsType>\n","import { LooseOptionsType, CreateOptionsType } from './Options'\nimport { objectKeys, objectsMergeDeep, WindowType } from './utils'\n\ntype OptionsType = Partial<CreateOptionsType<LooseOptionsType>>\n\nexport type OptionsHandlerType = {\n  mergeOptions: <TypeA extends OptionsType, TypeB extends OptionsType>(\n    optionsA: TypeA,\n    optionsB?: TypeB\n  ) => TypeA\n  optionsAtMedia: <Type extends OptionsType>(options: Type) => Type\n  optionsMediaQueries: (optionsList: OptionsType[]) => MediaQueryList[]\n}\n\nexport function OptionsHandler(ownerWindow: WindowType): OptionsHandlerType {\n  function mergeOptions<TypeA extends OptionsType, TypeB extends OptionsType>(\n    optionsA: TypeA,\n    optionsB?: TypeB\n  ): TypeA {\n    return <TypeA>objectsMergeDeep(optionsA, optionsB || {})\n  }\n\n  function optionsAtMedia<Type extends OptionsType>(options: Type): Type {\n    const optionsAtMedia = options.breakpoints || {}\n    const matchedMediaOptions = objectKeys(optionsAtMedia)\n      .filter((media) => ownerWindow.matchMedia(media).matches)\n      .map((media) => optionsAtMedia[media])\n      .reduce((a, mediaOption) => mergeOptions(a, mediaOption), {})\n\n    return mergeOptions(options, matchedMediaOptions)\n  }\n\n  function optionsMediaQueries(optionsList: OptionsType[]): MediaQueryList[] {\n    return optionsList\n      .map((options) => objectKeys(options.breakpoints || {}))\n      .reduce((acc, mediaQueries) => acc.concat(mediaQueries), [])\n      .map(ownerWindow.matchMedia)\n  }\n\n  const self: OptionsHandlerType = {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  }\n  return self\n}\n","import { Engine, EngineType } from './Engine'\nimport { EventStore } from './EventStore'\nimport { EventHandler, EventHandlerType } from './EventHandler'\nimport { defaultOptions, EmblaOptionsType, OptionsType } from './Options'\nimport { OptionsHandler } from './OptionsHandler'\nimport { PluginsHandler } from './PluginsHandler'\nimport { EmblaPluginsType, EmblaPluginType } from './Plugins'\nimport { isString, WindowType } from './utils'\n\nexport type EmblaCarouselType = {\n  canScrollNext: () => boolean\n  canScrollPrev: () => boolean\n  containerNode: () => HTMLElement\n  internalEngine: () => EngineType\n  destroy: () => void\n  off: EventHandlerType['off']\n  on: EventHandlerType['on']\n  emit: EventHandlerType['emit']\n  plugins: () => EmblaPluginsType\n  previousScrollSnap: () => number\n  reInit: (options?: EmblaOptionsType, plugins?: EmblaPluginType[]) => void\n  rootNode: () => HTMLElement\n  scrollNext: (jump?: boolean) => void\n  scrollPrev: (jump?: boolean) => void\n  scrollProgress: () => number\n  scrollSnapList: () => number[]\n  scrollTo: (index: number, jump?: boolean) => void\n  selectedScrollSnap: () => number\n  slideNodes: () => HTMLElement[]\n  slidesInView: () => number[]\n  slidesNotInView: () => number[]\n}\n\nfunction EmblaCarousel(\n  root: HTMLElement,\n  userOptions?: EmblaOptionsType,\n  userPlugins?: EmblaPluginType[]\n): EmblaCarouselType {\n  const ownerDocument = root.ownerDocument\n  const ownerWindow = <WindowType>ownerDocument.defaultView\n  const optionsHandler = OptionsHandler(ownerWindow)\n  const pluginsHandler = PluginsHandler(optionsHandler)\n  const mediaHandlers = EventStore()\n  const eventHandler = EventHandler()\n  const { mergeOptions, optionsAtMedia, optionsMediaQueries } = optionsHandler\n  const { on, off, emit } = eventHandler\n  const reInit = reActivate\n\n  let destroyed = false\n  let engine: EngineType\n  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions)\n  let options = mergeOptions(optionsBase)\n  let pluginList: EmblaPluginType[] = []\n  let pluginApis: EmblaPluginsType\n\n  let container: HTMLElement\n  let slides: HTMLElement[]\n\n  function storeElements(): void {\n    const { container: userContainer, slides: userSlides } = options\n\n    const customContainer = isString(userContainer)\n      ? root.querySelector(userContainer)\n      : userContainer\n    container = <HTMLElement>(customContainer || root.children[0])\n\n    const customSlides = isString(userSlides)\n      ? container.querySelectorAll(userSlides)\n      : userSlides\n    slides = <HTMLElement[]>[].slice.call(customSlides || container.children)\n  }\n\n  function createEngine(options: OptionsType): EngineType {\n    const engine = Engine(\n      root,\n      container,\n      slides,\n      ownerDocument,\n      ownerWindow,\n      options,\n      eventHandler\n    )\n\n    if (options.loop && !engine.slideLooper.canLoop()) {\n      const optionsWithoutLoop = Object.assign({}, options, { loop: false })\n      return createEngine(optionsWithoutLoop)\n    }\n    return engine\n  }\n\n  function activate(\n    withOptions?: EmblaOptionsType,\n    withPlugins?: EmblaPluginType[]\n  ): void {\n    if (destroyed) return\n\n    optionsBase = mergeOptions(optionsBase, withOptions)\n    options = optionsAtMedia(optionsBase)\n    pluginList = withPlugins || pluginList\n\n    storeElements()\n\n    engine = createEngine(options)\n\n    optionsMediaQueries([\n      optionsBase,\n      ...pluginList.map(({ options }) => options)\n    ]).forEach((query) => mediaHandlers.add(query, 'change', reActivate))\n\n    if (!options.active) return\n\n    engine.translate.to(engine.location.get())\n    engine.animation.init()\n    engine.slidesInView.init()\n    engine.slideFocus.init(self)\n    engine.eventHandler.init(self)\n    engine.resizeHandler.init(self)\n    engine.slidesHandler.init(self)\n\n    if (engine.options.loop) engine.slideLooper.loop()\n    if (container.offsetParent && slides.length) engine.dragHandler.init(self)\n\n    pluginApis = pluginsHandler.init(self, pluginList)\n  }\n\n  function reActivate(\n    withOptions?: EmblaOptionsType,\n    withPlugins?: EmblaPluginType[]\n  ): void {\n    const startIndex = selectedScrollSnap()\n    deActivate()\n    activate(mergeOptions({ startIndex }, withOptions), withPlugins)\n    eventHandler.emit('reInit')\n  }\n\n  function deActivate(): void {\n    engine.dragHandler.destroy()\n    engine.eventStore.clear()\n    engine.translate.clear()\n    engine.slideLooper.clear()\n    engine.resizeHandler.destroy()\n    engine.slidesHandler.destroy()\n    engine.slidesInView.destroy()\n    engine.animation.destroy()\n    pluginsHandler.destroy()\n    mediaHandlers.clear()\n  }\n\n  function destroy(): void {\n    if (destroyed) return\n    destroyed = true\n    mediaHandlers.clear()\n    deActivate()\n    eventHandler.emit('destroy')\n    eventHandler.clear()\n  }\n\n  function scrollTo(index: number, jump?: boolean, direction?: number): void {\n    if (!options.active || destroyed) return\n    engine.scrollBody\n      .useBaseFriction()\n      .useDuration(jump === true ? 0 : options.duration)\n    engine.scrollTo.index(index, direction || 0)\n  }\n\n  function scrollNext(jump?: boolean): void {\n    const next = engine.index.add(1).get()\n    scrollTo(next, jump, -1)\n  }\n\n  function scrollPrev(jump?: boolean): void {\n    const prev = engine.index.add(-1).get()\n    scrollTo(prev, jump, 1)\n  }\n\n  function canScrollNext(): boolean {\n    const next = engine.index.add(1).get()\n    return next !== selectedScrollSnap()\n  }\n\n  function canScrollPrev(): boolean {\n    const prev = engine.index.add(-1).get()\n    return prev !== selectedScrollSnap()\n  }\n\n  function scrollSnapList(): number[] {\n    return engine.scrollSnapList\n  }\n\n  function scrollProgress(): number {\n    return engine.scrollProgress.get(engine.location.get())\n  }\n\n  function selectedScrollSnap(): number {\n    return engine.index.get()\n  }\n\n  function previousScrollSnap(): number {\n    return engine.indexPrevious.get()\n  }\n\n  function slidesInView(): number[] {\n    return engine.slidesInView.get()\n  }\n\n  function slidesNotInView(): number[] {\n    return engine.slidesInView.get(false)\n  }\n\n  function plugins(): EmblaPluginsType {\n    return pluginApis\n  }\n\n  function internalEngine(): EngineType {\n    return engine\n  }\n\n  function rootNode(): HTMLElement {\n    return root\n  }\n\n  function containerNode(): HTMLElement {\n    return container\n  }\n\n  function slideNodes(): HTMLElement[] {\n    return slides\n  }\n\n  const self: EmblaCarouselType = {\n    canScrollNext,\n    canScrollPrev,\n    containerNode,\n    internalEngine,\n    destroy,\n    off,\n    on,\n    emit,\n    plugins,\n    previousScrollSnap,\n    reInit,\n    rootNode,\n    scrollNext,\n    scrollPrev,\n    scrollProgress,\n    scrollSnapList,\n    scrollTo,\n    selectedScrollSnap,\n    slideNodes,\n    slidesInView,\n    slidesNotInView\n  }\n\n  activate(userOptions, userPlugins)\n  setTimeout(() => eventHandler.emit('init'), 0)\n  return self\n}\n\ndeclare namespace EmblaCarousel {\n  let globalOptions: EmblaOptionsType | undefined\n}\n\nEmblaCarousel.globalOptions = undefined\n\nexport default EmblaCarousel\n","import { EmblaCarouselType } from './EmblaCarousel'\nimport { OptionsHandlerType } from './OptionsHandler'\nimport { EmblaPluginsType, EmblaPluginType } from './Plugins'\n\nexport type PluginsHandlerType = {\n  init: (\n    emblaApi: EmblaCarouselType,\n    plugins: EmblaPluginType[]\n  ) => EmblaPluginsType\n  destroy: () => void\n}\n\nexport function PluginsHandler(\n  optionsHandler: OptionsHandlerType\n): PluginsHandlerType {\n  let activePlugins: EmblaPluginType[] = []\n\n  function init(\n    emblaApi: EmblaCarouselType,\n    plugins: EmblaPluginType[]\n  ): EmblaPluginsType {\n    activePlugins = plugins.filter(\n      ({ options }) => optionsHandler.optionsAtMedia(options).active !== false\n    )\n    activePlugins.forEach((plugin) => plugin.init(emblaApi, optionsHandler))\n\n    return plugins.reduce(\n      (map, plugin) => Object.assign(map, { [plugin.name]: plugin }),\n      {}\n    )\n  }\n\n  function destroy(): void {\n    activePlugins = activePlugins.filter((plugin) => plugin.destroy())\n  }\n\n  const self: PluginsHandlerType = {\n    init,\n    destroy\n  }\n  return self\n}\n","import { EmblaCarouselType } from './EmblaCarousel'\n\ntype CallbackType = (emblaApi: EmblaCarouselType, evt: EmblaEventType) => void\ntype ListenersType = Partial<{ [key in EmblaEventType]: CallbackType[] }>\n\nexport type EmblaEventType = EmblaEventListType[keyof EmblaEventListType]\n\nexport interface EmblaEventListType {\n  init: 'init'\n  pointerDown: 'pointerDown'\n  pointerUp: 'pointerUp'\n  slidesChanged: 'slidesChanged'\n  slidesInView: 'slidesInView'\n  scroll: 'scroll'\n  select: 'select'\n  settle: 'settle'\n  destroy: 'destroy'\n  reInit: 'reInit'\n  resize: 'resize'\n  slideFocusStart: 'slideFocusStart'\n  slideFocus: 'slideFocus'\n}\n\nexport type EventHandlerType = {\n  init: (emblaApi: EmblaCarouselType) => void\n  emit: (evt: EmblaEventType) => EventHandlerType\n  on: (evt: EmblaEventType, cb: CallbackType) => EventHandlerType\n  off: (evt: EmblaEventType, cb: CallbackType) => EventHandlerType\n  clear: () => void\n}\n\nexport function EventHandler(): EventHandlerType {\n  let listeners: ListenersType = {}\n  let api: EmblaCarouselType\n\n  function init(emblaApi: EmblaCarouselType): void {\n    api = emblaApi\n  }\n\n  function getListeners(evt: EmblaEventType): CallbackType[] {\n    return listeners[evt] || []\n  }\n\n  function emit(evt: EmblaEventType): EventHandlerType {\n    getListeners(evt).forEach((e) => e(api, evt))\n    return self\n  }\n\n  function on(evt: EmblaEventType, cb: CallbackType): EventHandlerType {\n    listeners[evt] = getListeners(evt).concat([cb])\n    return self\n  }\n\n  function off(evt: EmblaEventType, cb: CallbackType): EventHandlerType {\n    listeners[evt] = getListeners(evt).filter((e) => e !== cb)\n    return self\n  }\n\n  function clear(): void {\n    listeners = {}\n  }\n\n  const self: EventHandlerType = {\n    init,\n    emit,\n    off,\n    on,\n    clear\n  }\n  return self\n}\n","import { useRef, useEffect, useState, useCallback } from 'react'\nimport {\n  areOptionsEqual,\n  arePluginsEqual,\n  canUseDOM\n} from 'embla-carousel-reactive-utils'\nimport EmblaCarousel, {\n  EmblaCarouselType,\n  EmblaOptionsType,\n  EmblaPluginType\n} from 'embla-carousel'\n\nexport type EmblaViewportRefType = <ViewportElement extends HTMLElement>(\n  instance: ViewportElement | null\n) => void\n\nexport type UseEmblaCarouselType = [\n  EmblaViewportRefType,\n  EmblaCarouselType | undefined\n]\n\nfunction useEmblaCarousel(\n  options: EmblaOptionsType = {},\n  plugins: EmblaPluginType[] = []\n): UseEmblaCarouselType {\n  const storedOptions = useRef(options)\n  const storedPlugins = useRef(plugins)\n  const [emblaApi, setEmblaApi] = useState<EmblaCarouselType>()\n  const [viewport, setViewport] = useState<HTMLElement>()\n\n  const reInit = useCallback(() => {\n    if (emblaApi) emblaApi.reInit(storedOptions.current, storedPlugins.current)\n  }, [emblaApi])\n\n  useEffect(() => {\n    if (areOptionsEqual(storedOptions.current, options)) return\n    storedOptions.current = options\n    reInit()\n  }, [options, reInit])\n\n  useEffect(() => {\n    if (arePluginsEqual(storedPlugins.current, plugins)) return\n    storedPlugins.current = plugins\n    reInit()\n  }, [plugins, reInit])\n\n  useEffect(() => {\n    if (canUseDOM() && viewport) {\n      EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions\n      const newEmblaApi = EmblaCarousel(\n        viewport,\n        storedOptions.current,\n        storedPlugins.current\n      )\n      setEmblaApi(newEmblaApi)\n      return () => newEmblaApi.destroy()\n    } else {\n      setEmblaApi(undefined)\n    }\n  }, [viewport, setEmblaApi])\n\n  return [<EmblaViewportRefType>setViewport, emblaApi]\n}\n\ndeclare namespace useEmblaCarousel {\n  let globalOptions: EmblaOptionsType | undefined\n}\n\nuseEmblaCarousel.globalOptions = undefined\n\nexport default useEmblaCarousel\n","const PACKET_TYPES = Object.create(null); // no Map = no polyfill\nPACKET_TYPES[\"open\"] = \"0\";\nPACKET_TYPES[\"close\"] = \"1\";\nPACKET_TYPES[\"ping\"] = \"2\";\nPACKET_TYPES[\"pong\"] = \"3\";\nPACKET_TYPES[\"message\"] = \"4\";\nPACKET_TYPES[\"upgrade\"] = \"5\";\nPACKET_TYPES[\"noop\"] = \"6\";\nconst PACKET_TYPES_REVERSE = Object.create(null);\nObject.keys(PACKET_TYPES).forEach((key) => {\n    PACKET_TYPES_REVERSE[PACKET_TYPES[key]] = key;\n});\nconst ERROR_PACKET = { type: \"error\", data: \"parser error\" };\nexport { PACKET_TYPES, PACKET_TYPES_REVERSE, ERROR_PACKET };\n","import { PACKET_TYPES } from \"./commons.js\";\nconst withNativeBlob = typeof Blob === \"function\" ||\n    (typeof Blob !== \"undefined\" &&\n        Object.prototype.toString.call(Blob) === \"[object BlobConstructor]\");\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\n// ArrayBuffer.isView method is not defined in IE10\nconst isView = (obj) => {\n    return typeof ArrayBuffer.isView === \"function\"\n        ? ArrayBuffer.isView(obj)\n        : obj && obj.buffer instanceof ArrayBuffer;\n};\nconst encodePacket = ({ type, data }, supportsBinary, callback) => {\n    if (withNativeBlob && data instanceof Blob) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(data, callback);\n        }\n    }\n    else if (withNativeArrayBuffer &&\n        (data instanceof ArrayBuffer || isView(data))) {\n        if (supportsBinary) {\n            return callback(data);\n        }\n        else {\n            return encodeBlobAsBase64(new Blob([data]), callback);\n        }\n    }\n    // plain string\n    return callback(PACKET_TYPES[type] + (data || \"\"));\n};\nconst encodeBlobAsBase64 = (data, callback) => {\n    const fileReader = new FileReader();\n    fileReader.onload = function () {\n        const content = fileReader.result.split(\",\")[1];\n        callback(\"b\" + (content || \"\"));\n    };\n    return fileReader.readAsDataURL(data);\n};\nfunction toArray(data) {\n    if (data instanceof Uint8Array) {\n        return data;\n    }\n    else if (data instanceof ArrayBuffer) {\n        return new Uint8Array(data);\n    }\n    else {\n        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);\n    }\n}\nlet TEXT_ENCODER;\nexport function encodePacketToBinary(packet, callback) {\n    if (withNativeBlob && packet.data instanceof Blob) {\n        return packet.data.arrayBuffer().then(toArray).then(callback);\n    }\n    else if (withNativeArrayBuffer &&\n        (packet.data instanceof ArrayBuffer || isView(packet.data))) {\n        return callback(toArray(packet.data));\n    }\n    encodePacket(packet, false, (encoded) => {\n        if (!TEXT_ENCODER) {\n            TEXT_ENCODER = new TextEncoder();\n        }\n        callback(TEXT_ENCODER.encode(encoded));\n    });\n}\nexport { encodePacket };\n","// imported from https://github.com/socketio/base64-arraybuffer\nconst chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n// Use a lookup table to find the index.\nconst lookup = typeof Uint8Array === 'undefined' ? [] : new Uint8Array(256);\nfor (let i = 0; i < chars.length; i++) {\n    lookup[chars.charCodeAt(i)] = i;\n}\nexport const encode = (arraybuffer) => {\n    let bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = '';\n    for (i = 0; i < len; i += 3) {\n        base64 += chars[bytes[i] >> 2];\n        base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n        base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n        base64 += chars[bytes[i + 2] & 63];\n    }\n    if (len % 3 === 2) {\n        base64 = base64.substring(0, base64.length - 1) + '=';\n    }\n    else if (len % 3 === 1) {\n        base64 = base64.substring(0, base64.length - 2) + '==';\n    }\n    return base64;\n};\nexport const decode = (base64) => {\n    let bufferLength = base64.length * 0.75, len = base64.length, i, p = 0, encoded1, encoded2, encoded3, encoded4;\n    if (base64[base64.length - 1] === '=') {\n        bufferLength--;\n        if (base64[base64.length - 2] === '=') {\n            bufferLength--;\n        }\n    }\n    const arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer);\n    for (i = 0; i < len; i += 4) {\n        encoded1 = lookup[base64.charCodeAt(i)];\n        encoded2 = lookup[base64.charCodeAt(i + 1)];\n        encoded3 = lookup[base64.charCodeAt(i + 2)];\n        encoded4 = lookup[base64.charCodeAt(i + 3)];\n        bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n        bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n        bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n    }\n    return arraybuffer;\n};\n","import { ERROR_PACKET, PACKET_TYPES_REVERSE, } from \"./commons.js\";\nimport { decode } from \"./contrib/base64-arraybuffer.js\";\nconst withNativeArrayBuffer = typeof ArrayBuffer === \"function\";\nexport const decodePacket = (encodedPacket, binaryType) => {\n    if (typeof encodedPacket !== \"string\") {\n        return {\n            type: \"message\",\n            data: mapBinary(encodedPacket, binaryType),\n        };\n    }\n    const type = encodedPacket.charAt(0);\n    if (type === \"b\") {\n        return {\n            type: \"message\",\n            data: decodeBase64Packet(encodedPacket.substring(1), binaryType),\n        };\n    }\n    const packetType = PACKET_TYPES_REVERSE[type];\n    if (!packetType) {\n        return ERROR_PACKET;\n    }\n    return encodedPacket.length > 1\n        ? {\n            type: PACKET_TYPES_REVERSE[type],\n            data: encodedPacket.substring(1),\n        }\n        : {\n            type: PACKET_TYPES_REVERSE[type],\n        };\n};\nconst decodeBase64Packet = (data, binaryType) => {\n    if (withNativeArrayBuffer) {\n        const decoded = decode(data);\n        return mapBinary(decoded, binaryType);\n    }\n    else {\n        return { base64: true, data }; // fallback for old browsers\n    }\n};\nconst mapBinary = (data, binaryType) => {\n    switch (binaryType) {\n        case \"blob\":\n            if (data instanceof Blob) {\n                // from WebSocket + binaryType \"blob\"\n                return data;\n            }\n            else {\n                // from HTTP long-polling or WebTransport\n                return new Blob([data]);\n            }\n        case \"arraybuffer\":\n        default:\n            if (data instanceof ArrayBuffer) {\n                // from HTTP long-polling (base64) or WebSocket + binaryType \"arraybuffer\"\n                return data;\n            }\n            else {\n                // from WebTransport (Uint8Array)\n                return data.buffer;\n            }\n    }\n};\n","import { encodePacket, encodePacketToBinary } from \"./encodePacket.js\";\nimport { decodePacket } from \"./decodePacket.js\";\nimport { ERROR_PACKET, } from \"./commons.js\";\nconst SEPARATOR = String.fromCharCode(30); // see https://en.wikipedia.org/wiki/Delimiter#ASCII_delimited_text\nconst encodePayload = (packets, callback) => {\n    // some packets may be added to the array while encoding, so the initial length must be saved\n    const length = packets.length;\n    const encodedPackets = new Array(length);\n    let count = 0;\n    packets.forEach((packet, i) => {\n        // force base64 encoding for binary packets\n        encodePacket(packet, false, (encodedPacket) => {\n            encodedPackets[i] = encodedPacket;\n            if (++count === length) {\n                callback(encodedPackets.join(SEPARATOR));\n            }\n        });\n    });\n};\nconst decodePayload = (encodedPayload, binaryType) => {\n    const encodedPackets = encodedPayload.split(SEPARATOR);\n    const packets = [];\n    for (let i = 0; i < encodedPackets.length; i++) {\n        const decodedPacket = decodePacket(encodedPackets[i], binaryType);\n        packets.push(decodedPacket);\n        if (decodedPacket.type === \"error\") {\n            break;\n        }\n    }\n    return packets;\n};\nexport function createPacketEncoderStream() {\n    return new TransformStream({\n        transform(packet, controller) {\n            encodePacketToBinary(packet, (encodedPacket) => {\n                const payloadLength = encodedPacket.length;\n                let header;\n                // inspired by the WebSocket format: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API/Writing_WebSocket_servers#decoding_payload_length\n                if (payloadLength < 126) {\n                    header = new Uint8Array(1);\n                    new DataView(header.buffer).setUint8(0, payloadLength);\n                }\n                else if (payloadLength < 65536) {\n                    header = new Uint8Array(3);\n                    const view = new DataView(header.buffer);\n                    view.setUint8(0, 126);\n                    view.setUint16(1, payloadLength);\n                }\n                else {\n                    header = new Uint8Array(9);\n                    const view = new DataView(header.buffer);\n                    view.setUint8(0, 127);\n                    view.setBigUint64(1, BigInt(payloadLength));\n                }\n                // first bit indicates whether the payload is plain text (0) or binary (1)\n                if (packet.data && typeof packet.data !== \"string\") {\n                    header[0] |= 0x80;\n                }\n                controller.enqueue(header);\n                controller.enqueue(encodedPacket);\n            });\n        },\n    });\n}\nlet TEXT_DECODER;\nfunction totalLength(chunks) {\n    return chunks.reduce((acc, chunk) => acc + chunk.length, 0);\n}\nfunction concatChunks(chunks, size) {\n    if (chunks[0].length === size) {\n        return chunks.shift();\n    }\n    const buffer = new Uint8Array(size);\n    let j = 0;\n    for (let i = 0; i < size; i++) {\n        buffer[i] = chunks[0][j++];\n        if (j === chunks[0].length) {\n            chunks.shift();\n            j = 0;\n        }\n    }\n    if (chunks.length && j < chunks[0].length) {\n        chunks[0] = chunks[0].slice(j);\n    }\n    return buffer;\n}\nexport function createPacketDecoderStream(maxPayload, binaryType) {\n    if (!TEXT_DECODER) {\n        TEXT_DECODER = new TextDecoder();\n    }\n    const chunks = [];\n    let state = 0 /* State.READ_HEADER */;\n    let expectedLength = -1;\n    let isBinary = false;\n    return new TransformStream({\n        transform(chunk, controller) {\n            chunks.push(chunk);\n            while (true) {\n                if (state === 0 /* State.READ_HEADER */) {\n                    if (totalLength(chunks) < 1) {\n                        break;\n                    }\n                    const header = concatChunks(chunks, 1);\n                    isBinary = (header[0] & 0x80) === 0x80;\n                    expectedLength = header[0] & 0x7f;\n                    if (expectedLength < 126) {\n                        state = 3 /* State.READ_PAYLOAD */;\n                    }\n                    else if (expectedLength === 126) {\n                        state = 1 /* State.READ_EXTENDED_LENGTH_16 */;\n                    }\n                    else {\n                        state = 2 /* State.READ_EXTENDED_LENGTH_64 */;\n                    }\n                }\n                else if (state === 1 /* State.READ_EXTENDED_LENGTH_16 */) {\n                    if (totalLength(chunks) < 2) {\n                        break;\n                    }\n                    const headerArray = concatChunks(chunks, 2);\n                    expectedLength = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length).getUint16(0);\n                    state = 3 /* State.READ_PAYLOAD */;\n                }\n                else if (state === 2 /* State.READ_EXTENDED_LENGTH_64 */) {\n                    if (totalLength(chunks) < 8) {\n                        break;\n                    }\n                    const headerArray = concatChunks(chunks, 8);\n                    const view = new DataView(headerArray.buffer, headerArray.byteOffset, headerArray.length);\n                    const n = view.getUint32(0);\n                    if (n > Math.pow(2, 53 - 32) - 1) {\n                        // the maximum safe integer in JavaScript is 2^53 - 1\n                        controller.enqueue(ERROR_PACKET);\n                        break;\n                    }\n                    expectedLength = n * Math.pow(2, 32) + view.getUint32(4);\n                    state = 3 /* State.READ_PAYLOAD */;\n                }\n                else {\n                    if (totalLength(chunks) < expectedLength) {\n                        break;\n                    }\n                    const data = concatChunks(chunks, expectedLength);\n                    controller.enqueue(decodePacket(isBinary ? data : TEXT_DECODER.decode(data), binaryType));\n                    state = 0 /* State.READ_HEADER */;\n                }\n                if (expectedLength === 0 || expectedLength > maxPayload) {\n                    controller.enqueue(ERROR_PACKET);\n                    break;\n                }\n            }\n        },\n    });\n}\nexport const protocol = 4;\nexport { encodePacket, encodePayload, decodePacket, decodePayload, };\n","export const nextTick = (() => {\n    const isPromiseAvailable = typeof Promise === \"function\" && typeof Promise.resolve === \"function\";\n    if (isPromiseAvailable) {\n        return (cb) => Promise.resolve().then(cb);\n    }\n    else {\n        return (cb, setTimeoutFn) => setTimeoutFn(cb, 0);\n    }\n})();\nexport const globalThisShim = (() => {\n    if (typeof self !== \"undefined\") {\n        return self;\n    }\n    else if (typeof window !== \"undefined\") {\n        return window;\n    }\n    else {\n        return Function(\"return this\")();\n    }\n})();\nexport const defaultBinaryType = \"arraybuffer\";\nexport function createCookieJar() { }\n","import { globalThisShim as globalThis } from \"./globals.node.js\";\nexport function pick(obj, ...attr) {\n    return attr.reduce((acc, k) => {\n        if (obj.hasOwnProperty(k)) {\n            acc[k] = obj[k];\n        }\n        return acc;\n    }, {});\n}\n// Keep a reference to the real timeout functions so they can be used when overridden\nconst NATIVE_SET_TIMEOUT = globalThis.setTimeout;\nconst NATIVE_CLEAR_TIMEOUT = globalThis.clearTimeout;\nexport function installTimerFunctions(obj, opts) {\n    if (opts.useNativeTimers) {\n        obj.setTimeoutFn = NATIVE_SET_TIMEOUT.bind(globalThis);\n        obj.clearTimeoutFn = NATIVE_CLEAR_TIMEOUT.bind(globalThis);\n    }\n    else {\n        obj.setTimeoutFn = globalThis.setTimeout.bind(globalThis);\n        obj.clearTimeoutFn = globalThis.clearTimeout.bind(globalThis);\n    }\n}\n// base64 encoded buffers are about 33% bigger (https://en.wikipedia.org/wiki/Base64)\nconst BASE64_OVERHEAD = 1.33;\n// we could also have used `new Blob([obj]).size`, but it isn't supported in IE9\nexport function byteLength(obj) {\n    if (typeof obj === \"string\") {\n        return utf8Length(obj);\n    }\n    // arraybuffer or blob\n    return Math.ceil((obj.byteLength || obj.size) * BASE64_OVERHEAD);\n}\nfunction utf8Length(str) {\n    let c = 0, length = 0;\n    for (let i = 0, l = str.length; i < l; i++) {\n        c = str.charCodeAt(i);\n        if (c < 0x80) {\n            length += 1;\n        }\n        else if (c < 0x800) {\n            length += 2;\n        }\n        else if (c < 0xd800 || c >= 0xe000) {\n            length += 3;\n        }\n        else {\n            i++;\n            length += 4;\n        }\n    }\n    return length;\n}\n/**\n * Generates a random 8-characters string.\n */\nexport function randomString() {\n    return (Date.now().toString(36).substring(3) +\n        Math.random().toString(36).substring(2, 5));\n}\n","import { decodePacket } from \"engine.io-parser\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { installTimerFunctions } from \"./util.js\";\nimport { encode } from \"./contrib/parseqs.js\";\nexport class TransportError extends Error {\n    constructor(reason, description, context) {\n        super(reason);\n        this.description = description;\n        this.context = context;\n        this.type = \"TransportError\";\n    }\n}\nexport class Transport extends Emitter {\n    /**\n     * Transport abstract constructor.\n     *\n     * @param {Object} opts - options\n     * @protected\n     */\n    constructor(opts) {\n        super();\n        this.writable = false;\n        installTimerFunctions(this, opts);\n        this.opts = opts;\n        this.query = opts.query;\n        this.socket = opts.socket;\n        this.supportsBinary = !opts.forceBase64;\n    }\n    /**\n     * Emits an error.\n     *\n     * @param {String} reason\n     * @param description\n     * @param context - the error context\n     * @return {Transport} for chaining\n     * @protected\n     */\n    onError(reason, description, context) {\n        super.emitReserved(\"error\", new TransportError(reason, description, context));\n        return this;\n    }\n    /**\n     * Opens the transport.\n     */\n    open() {\n        this.readyState = \"opening\";\n        this.doOpen();\n        return this;\n    }\n    /**\n     * Closes the transport.\n     */\n    close() {\n        if (this.readyState === \"opening\" || this.readyState === \"open\") {\n            this.doClose();\n            this.onClose();\n        }\n        return this;\n    }\n    /**\n     * Sends multiple packets.\n     *\n     * @param {Array} packets\n     */\n    send(packets) {\n        if (this.readyState === \"open\") {\n            this.write(packets);\n        }\n        else {\n            // this might happen if the transport was silently closed in the beforeunload event handler\n        }\n    }\n    /**\n     * Called upon open\n     *\n     * @protected\n     */\n    onOpen() {\n        this.readyState = \"open\";\n        this.writable = true;\n        super.emitReserved(\"open\");\n    }\n    /**\n     * Called with data.\n     *\n     * @param {String} data\n     * @protected\n     */\n    onData(data) {\n        const packet = decodePacket(data, this.socket.binaryType);\n        this.onPacket(packet);\n    }\n    /**\n     * Called with a decoded packet.\n     *\n     * @protected\n     */\n    onPacket(packet) {\n        super.emitReserved(\"packet\", packet);\n    }\n    /**\n     * Called upon close.\n     *\n     * @protected\n     */\n    onClose(details) {\n        this.readyState = \"closed\";\n        super.emitReserved(\"close\", details);\n    }\n    /**\n     * Pauses the transport, in order not to lose packets during an upgrade.\n     *\n     * @param onPause\n     */\n    pause(onPause) { }\n    createUri(schema, query = {}) {\n        return (schema +\n            \"://\" +\n            this._hostname() +\n            this._port() +\n            this.opts.path +\n            this._query(query));\n    }\n    _hostname() {\n        const hostname = this.opts.hostname;\n        return hostname.indexOf(\":\") === -1 ? hostname : \"[\" + hostname + \"]\";\n    }\n    _port() {\n        if (this.opts.port &&\n            ((this.opts.secure && Number(this.opts.port !== 443)) ||\n                (!this.opts.secure && Number(this.opts.port) !== 80))) {\n            return \":\" + this.opts.port;\n        }\n        else {\n            return \"\";\n        }\n    }\n    _query(query) {\n        const encodedQuery = encode(query);\n        return encodedQuery.length ? \"?\" + encodedQuery : \"\";\n    }\n}\n","// imported from https://github.com/galkn/querystring\n/**\n * Compiles a querystring\n * Returns string representation of the object\n *\n * @param {Object}\n * @api private\n */\nexport function encode(obj) {\n    let str = '';\n    for (let i in obj) {\n        if (obj.hasOwnProperty(i)) {\n            if (str.length)\n                str += '&';\n            str += encodeURIComponent(i) + '=' + encodeURIComponent(obj[i]);\n        }\n    }\n    return str;\n}\n/**\n * Parses a simple querystring into an object\n *\n * @param {String} qs\n * @api private\n */\nexport function decode(qs) {\n    let qry = {};\n    let pairs = qs.split('&');\n    for (let i = 0, l = pairs.length; i < l; i++) {\n        let pair = pairs[i].split('=');\n        qry[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);\n    }\n    return qry;\n}\n","import { Transport } from \"../transport.js\";\nimport { randomString } from \"../util.js\";\nimport { encodePayload, decodePayload } from \"engine.io-parser\";\nexport class Polling extends Transport {\n    constructor() {\n        super(...arguments);\n        this._polling = false;\n    }\n    get name() {\n        return \"polling\";\n    }\n    /**\n     * Opens the socket (triggers polling). We write a PING message to determine\n     * when the transport is open.\n     *\n     * @protected\n     */\n    doOpen() {\n        this._poll();\n    }\n    /**\n     * Pauses polling.\n     *\n     * @param {Function} onPause - callback upon buffers are flushed and transport is paused\n     * @package\n     */\n    pause(onPause) {\n        this.readyState = \"pausing\";\n        const pause = () => {\n            this.readyState = \"paused\";\n            onPause();\n        };\n        if (this._polling || !this.writable) {\n            let total = 0;\n            if (this._polling) {\n                total++;\n                this.once(\"pollComplete\", function () {\n                    --total || pause();\n                });\n            }\n            if (!this.writable) {\n                total++;\n                this.once(\"drain\", function () {\n                    --total || pause();\n                });\n            }\n        }\n        else {\n            pause();\n        }\n    }\n    /**\n     * Starts polling cycle.\n     *\n     * @private\n     */\n    _poll() {\n        this._polling = true;\n        this.doPoll();\n        this.emitReserved(\"poll\");\n    }\n    /**\n     * Overloads onData to detect payloads.\n     *\n     * @protected\n     */\n    onData(data) {\n        const callback = (packet) => {\n            // if its the first message we consider the transport open\n            if (\"opening\" === this.readyState && packet.type === \"open\") {\n                this.onOpen();\n            }\n            // if its a close packet, we close the ongoing requests\n            if (\"close\" === packet.type) {\n                this.onClose({ description: \"transport closed by the server\" });\n                return false;\n            }\n            // otherwise bypass onData and handle the message\n            this.onPacket(packet);\n        };\n        // decode payload\n        decodePayload(data, this.socket.binaryType).forEach(callback);\n        // if an event did not trigger closing\n        if (\"closed\" !== this.readyState) {\n            // if we got data we're not polling\n            this._polling = false;\n            this.emitReserved(\"pollComplete\");\n            if (\"open\" === this.readyState) {\n                this._poll();\n            }\n            else {\n            }\n        }\n    }\n    /**\n     * For polling, send a close packet.\n     *\n     * @protected\n     */\n    doClose() {\n        const close = () => {\n            this.write([{ type: \"close\" }]);\n        };\n        if (\"open\" === this.readyState) {\n            close();\n        }\n        else {\n            // in case we're trying to close while\n            // handshaking is in progress (GH-164)\n            this.once(\"open\", close);\n        }\n    }\n    /**\n     * Writes a packets payload.\n     *\n     * @param {Array} packets - data packets\n     * @protected\n     */\n    write(packets) {\n        this.writable = false;\n        encodePayload(packets, (data) => {\n            this.doWrite(data, () => {\n                this.writable = true;\n                this.emitReserved(\"drain\");\n            });\n        });\n    }\n    /**\n     * Generates uri for connection.\n     *\n     * @private\n     */\n    uri() {\n        const schema = this.opts.secure ? \"https\" : \"http\";\n        const query = this.query || {};\n        // cache busting is forced\n        if (false !== this.opts.timestampRequests) {\n            query[this.opts.timestampParam] = randomString();\n        }\n        if (!this.supportsBinary && !query.sid) {\n            query.b64 = 1;\n        }\n        return this.createUri(schema, query);\n    }\n}\n","// imported from https://github.com/component/has-cors\nlet value = false;\ntry {\n    value = typeof XMLHttpRequest !== 'undefined' &&\n        'withCredentials' in new XMLHttpRequest();\n}\ncatch (err) {\n    // if XMLHttp support is disabled in IE then it will throw\n    // when trying to create\n}\nexport const hasCORS = value;\n","import { Polling } from \"./polling.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { installTimerFunctions, pick } from \"../util.js\";\nimport { globalThisShim as globalThis } from \"../globals.node.js\";\nimport { hasCORS } from \"../contrib/has-cors.js\";\nfunction empty() { }\nexport class BaseXHR extends Polling {\n    /**\n     * XHR Polling constructor.\n     *\n     * @param {Object} opts\n     * @package\n     */\n    constructor(opts) {\n        super(opts);\n        if (typeof location !== \"undefined\") {\n            const isSSL = \"https:\" === location.protocol;\n            let port = location.port;\n            // some user agents have empty `location.port`\n            if (!port) {\n                port = isSSL ? \"443\" : \"80\";\n            }\n            this.xd =\n                (typeof location !== \"undefined\" &&\n                    opts.hostname !== location.hostname) ||\n                    port !== opts.port;\n        }\n    }\n    /**\n     * Sends data.\n     *\n     * @param {String} data to send.\n     * @param {Function} called upon flush.\n     * @private\n     */\n    doWrite(data, fn) {\n        const req = this.request({\n            method: \"POST\",\n            data: data,\n        });\n        req.on(\"success\", fn);\n        req.on(\"error\", (xhrStatus, context) => {\n            this.onError(\"xhr post error\", xhrStatus, context);\n        });\n    }\n    /**\n     * Starts a poll cycle.\n     *\n     * @private\n     */\n    doPoll() {\n        const req = this.request();\n        req.on(\"data\", this.onData.bind(this));\n        req.on(\"error\", (xhrStatus, context) => {\n            this.onError(\"xhr poll error\", xhrStatus, context);\n        });\n        this.pollXhr = req;\n    }\n}\nexport class Request extends Emitter {\n    /**\n     * Request constructor\n     *\n     * @param {Object} options\n     * @package\n     */\n    constructor(createRequest, uri, opts) {\n        super();\n        this.createRequest = createRequest;\n        installTimerFunctions(this, opts);\n        this._opts = opts;\n        this._method = opts.method || \"GET\";\n        this._uri = uri;\n        this._data = undefined !== opts.data ? opts.data : null;\n        this._create();\n    }\n    /**\n     * Creates the XHR object and sends the request.\n     *\n     * @private\n     */\n    _create() {\n        var _a;\n        const opts = pick(this._opts, \"agent\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"autoUnref\");\n        opts.xdomain = !!this._opts.xd;\n        const xhr = (this._xhr = this.createRequest(opts));\n        try {\n            xhr.open(this._method, this._uri, true);\n            try {\n                if (this._opts.extraHeaders) {\n                    // @ts-ignore\n                    xhr.setDisableHeaderCheck && xhr.setDisableHeaderCheck(true);\n                    for (let i in this._opts.extraHeaders) {\n                        if (this._opts.extraHeaders.hasOwnProperty(i)) {\n                            xhr.setRequestHeader(i, this._opts.extraHeaders[i]);\n                        }\n                    }\n                }\n            }\n            catch (e) { }\n            if (\"POST\" === this._method) {\n                try {\n                    xhr.setRequestHeader(\"Content-type\", \"text/plain;charset=UTF-8\");\n                }\n                catch (e) { }\n            }\n            try {\n                xhr.setRequestHeader(\"Accept\", \"*/*\");\n            }\n            catch (e) { }\n            (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.addCookies(xhr);\n            // ie6 check\n            if (\"withCredentials\" in xhr) {\n                xhr.withCredentials = this._opts.withCredentials;\n            }\n            if (this._opts.requestTimeout) {\n                xhr.timeout = this._opts.requestTimeout;\n            }\n            xhr.onreadystatechange = () => {\n                var _a;\n                if (xhr.readyState === 3) {\n                    (_a = this._opts.cookieJar) === null || _a === void 0 ? void 0 : _a.parseCookies(\n                    // @ts-ignore\n                    xhr.getResponseHeader(\"set-cookie\"));\n                }\n                if (4 !== xhr.readyState)\n                    return;\n                if (200 === xhr.status || 1223 === xhr.status) {\n                    this._onLoad();\n                }\n                else {\n                    // make sure the `error` event handler that's user-set\n                    // does not throw in the same tick and gets caught here\n                    this.setTimeoutFn(() => {\n                        this._onError(typeof xhr.status === \"number\" ? xhr.status : 0);\n                    }, 0);\n                }\n            };\n            xhr.send(this._data);\n        }\n        catch (e) {\n            // Need to defer since .create() is called directly from the constructor\n            // and thus the 'error' event can only be only bound *after* this exception\n            // occurs.  Therefore, also, we cannot throw here at all.\n            this.setTimeoutFn(() => {\n                this._onError(e);\n            }, 0);\n            return;\n        }\n        if (typeof document !== \"undefined\") {\n            this._index = Request.requestsCount++;\n            Request.requests[this._index] = this;\n        }\n    }\n    /**\n     * Called upon error.\n     *\n     * @private\n     */\n    _onError(err) {\n        this.emitReserved(\"error\", err, this._xhr);\n        this._cleanup(true);\n    }\n    /**\n     * Cleans up house.\n     *\n     * @private\n     */\n    _cleanup(fromError) {\n        if (\"undefined\" === typeof this._xhr || null === this._xhr) {\n            return;\n        }\n        this._xhr.onreadystatechange = empty;\n        if (fromError) {\n            try {\n                this._xhr.abort();\n            }\n            catch (e) { }\n        }\n        if (typeof document !== \"undefined\") {\n            delete Request.requests[this._index];\n        }\n        this._xhr = null;\n    }\n    /**\n     * Called upon load.\n     *\n     * @private\n     */\n    _onLoad() {\n        const data = this._xhr.responseText;\n        if (data !== null) {\n            this.emitReserved(\"data\", data);\n            this.emitReserved(\"success\");\n            this._cleanup();\n        }\n    }\n    /**\n     * Aborts the request.\n     *\n     * @package\n     */\n    abort() {\n        this._cleanup();\n    }\n}\nRequest.requestsCount = 0;\nRequest.requests = {};\n/**\n * Aborts pending requests when unloading the window. This is needed to prevent\n * memory leaks (e.g. when using IE) and to ensure that no spurious error is\n * emitted.\n */\nif (typeof document !== \"undefined\") {\n    // @ts-ignore\n    if (typeof attachEvent === \"function\") {\n        // @ts-ignore\n        attachEvent(\"onunload\", unloadHandler);\n    }\n    else if (typeof addEventListener === \"function\") {\n        const terminationEvent = \"onpagehide\" in globalThis ? \"pagehide\" : \"unload\";\n        addEventListener(terminationEvent, unloadHandler, false);\n    }\n}\nfunction unloadHandler() {\n    for (let i in Request.requests) {\n        if (Request.requests.hasOwnProperty(i)) {\n            Request.requests[i].abort();\n        }\n    }\n}\nconst hasXHR2 = (function () {\n    const xhr = newRequest({\n        xdomain: false,\n    });\n    return xhr && xhr.responseType !== null;\n})();\n/**\n * HTTP long-polling based on the built-in `XMLHttpRequest` object.\n *\n * Usage: browser\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest\n */\nexport class XHR extends BaseXHR {\n    constructor(opts) {\n        super(opts);\n        const forceBase64 = opts && opts.forceBase64;\n        this.supportsBinary = hasXHR2 && !forceBase64;\n    }\n    request(opts = {}) {\n        Object.assign(opts, { xd: this.xd }, this.opts);\n        return new Request(newRequest, this.uri(), opts);\n    }\n}\nfunction newRequest(opts) {\n    const xdomain = opts.xdomain;\n    // XMLHttpRequest can be disabled on IE\n    try {\n        if (\"undefined\" !== typeof XMLHttpRequest && (!xdomain || hasCORS)) {\n            return new XMLHttpRequest();\n        }\n    }\n    catch (e) { }\n    if (!xdomain) {\n        try {\n            return new globalThis[[\"Active\"].concat(\"Object\").join(\"X\")](\"Microsoft.XMLHTTP\");\n        }\n        catch (e) { }\n    }\n}\n","import { Transport } from \"../transport.js\";\nimport { pick, randomString } from \"../util.js\";\nimport { encodePacket } from \"engine.io-parser\";\nimport { globalThisShim as globalThis, nextTick } from \"../globals.node.js\";\n// detect ReactNative environment\nconst isReactNative = typeof navigator !== \"undefined\" &&\n    typeof navigator.product === \"string\" &&\n    navigator.product.toLowerCase() === \"reactnative\";\nexport class BaseWS extends Transport {\n    get name() {\n        return \"websocket\";\n    }\n    doOpen() {\n        const uri = this.uri();\n        const protocols = this.opts.protocols;\n        // React Native only supports the 'headers' option, and will print a warning if anything else is passed\n        const opts = isReactNative\n            ? {}\n            : pick(this.opts, \"agent\", \"perMessageDeflate\", \"pfx\", \"key\", \"passphrase\", \"cert\", \"ca\", \"ciphers\", \"rejectUnauthorized\", \"localAddress\", \"protocolVersion\", \"origin\", \"maxPayload\", \"family\", \"checkServerIdentity\");\n        if (this.opts.extraHeaders) {\n            opts.headers = this.opts.extraHeaders;\n        }\n        try {\n            this.ws = this.createSocket(uri, protocols, opts);\n        }\n        catch (err) {\n            return this.emitReserved(\"error\", err);\n        }\n        this.ws.binaryType = this.socket.binaryType;\n        this.addEventListeners();\n    }\n    /**\n     * Adds event listeners to the socket\n     *\n     * @private\n     */\n    addEventListeners() {\n        this.ws.onopen = () => {\n            if (this.opts.autoUnref) {\n                this.ws._socket.unref();\n            }\n            this.onOpen();\n        };\n        this.ws.onclose = (closeEvent) => this.onClose({\n            description: \"websocket connection closed\",\n            context: closeEvent,\n        });\n        this.ws.onmessage = (ev) => this.onData(ev.data);\n        this.ws.onerror = (e) => this.onError(\"websocket error\", e);\n    }\n    write(packets) {\n        this.writable = false;\n        // encodePacket efficient as it uses WS framing\n        // no need for encodePayload\n        for (let i = 0; i < packets.length; i++) {\n            const packet = packets[i];\n            const lastPacket = i === packets.length - 1;\n            encodePacket(packet, this.supportsBinary, (data) => {\n                // Sometimes the websocket has already been closed but the browser didn't\n                // have a chance of informing us about it yet, in that case send will\n                // throw an error\n                try {\n                    this.doWrite(packet, data);\n                }\n                catch (e) {\n                }\n                if (lastPacket) {\n                    // fake drain\n                    // defer to next tick to allow Socket to clear writeBuffer\n                    nextTick(() => {\n                        this.writable = true;\n                        this.emitReserved(\"drain\");\n                    }, this.setTimeoutFn);\n                }\n            });\n        }\n    }\n    doClose() {\n        if (typeof this.ws !== \"undefined\") {\n            this.ws.onerror = () => { };\n            this.ws.close();\n            this.ws = null;\n        }\n    }\n    /**\n     * Generates uri for connection.\n     *\n     * @private\n     */\n    uri() {\n        const schema = this.opts.secure ? \"wss\" : \"ws\";\n        const query = this.query || {};\n        // append timestamp to URI\n        if (this.opts.timestampRequests) {\n            query[this.opts.timestampParam] = randomString();\n        }\n        // communicate binary support capabilities\n        if (!this.supportsBinary) {\n            query.b64 = 1;\n        }\n        return this.createUri(schema, query);\n    }\n}\nconst WebSocketCtor = globalThis.WebSocket || globalThis.MozWebSocket;\n/**\n * WebSocket transport based on the built-in `WebSocket` object.\n *\n * Usage: browser, Node.js (since v21), Deno, Bun\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/WebSocket\n * @see https://caniuse.com/mdn-api_websocket\n * @see https://nodejs.org/api/globals.html#websocket\n */\nexport class WS extends BaseWS {\n    createSocket(uri, protocols, opts) {\n        return !isReactNative\n            ? protocols\n                ? new WebSocketCtor(uri, protocols)\n                : new WebSocketCtor(uri)\n            : new WebSocketCtor(uri, protocols, opts);\n    }\n    doWrite(_packet, data) {\n        this.ws.send(data);\n    }\n}\n","import { XHR } from \"./polling-xhr.node.js\";\nimport { WS } from \"./websocket.node.js\";\nimport { WT } from \"./webtransport.js\";\nexport const transports = {\n    websocket: WS,\n    webtransport: WT,\n    polling: XHR,\n};\n","import { Transport } from \"../transport.js\";\nimport { nextTick } from \"../globals.node.js\";\nimport { createPacketDecoderStream, createPacketEncoderStream, } from \"engine.io-parser\";\n/**\n * WebTransport transport based on the built-in `WebTransport` object.\n *\n * Usage: browser, Node.js (with the `@fails-components/webtransport` package)\n *\n * @see https://developer.mozilla.org/en-US/docs/Web/API/WebTransport\n * @see https://caniuse.com/webtransport\n */\nexport class WT extends Transport {\n    get name() {\n        return \"webtransport\";\n    }\n    doOpen() {\n        try {\n            // @ts-ignore\n            this._transport = new WebTransport(this.createUri(\"https\"), this.opts.transportOptions[this.name]);\n        }\n        catch (err) {\n            return this.emitReserved(\"error\", err);\n        }\n        this._transport.closed\n            .then(() => {\n            this.onClose();\n        })\n            .catch((err) => {\n            this.onError(\"webtransport error\", err);\n        });\n        // note: we could have used async/await, but that would require some additional polyfills\n        this._transport.ready.then(() => {\n            this._transport.createBidirectionalStream().then((stream) => {\n                const decoderStream = createPacketDecoderStream(Number.MAX_SAFE_INTEGER, this.socket.binaryType);\n                const reader = stream.readable.pipeThrough(decoderStream).getReader();\n                const encoderStream = createPacketEncoderStream();\n                encoderStream.readable.pipeTo(stream.writable);\n                this._writer = encoderStream.writable.getWriter();\n                const read = () => {\n                    reader\n                        .read()\n                        .then(({ done, value }) => {\n                        if (done) {\n                            return;\n                        }\n                        this.onPacket(value);\n                        read();\n                    })\n                        .catch((err) => {\n                    });\n                };\n                read();\n                const packet = { type: \"open\" };\n                if (this.query.sid) {\n                    packet.data = `{\"sid\":\"${this.query.sid}\"}`;\n                }\n                this._writer.write(packet).then(() => this.onOpen());\n            });\n        });\n    }\n    write(packets) {\n        this.writable = false;\n        for (let i = 0; i < packets.length; i++) {\n            const packet = packets[i];\n            const lastPacket = i === packets.length - 1;\n            this._writer.write(packet).then(() => {\n                if (lastPacket) {\n                    nextTick(() => {\n                        this.writable = true;\n                        this.emitReserved(\"drain\");\n                    }, this.setTimeoutFn);\n                }\n            });\n        }\n    }\n    doClose() {\n        var _a;\n        (_a = this._transport) === null || _a === void 0 ? void 0 : _a.close();\n    }\n}\n","// imported from https://github.com/galkn/parseuri\n/**\n * Parses a URI\n *\n * Note: we could also have used the built-in URL object, but it isn't supported on all platforms.\n *\n * See:\n * - https://developer.mozilla.org/en-US/docs/Web/API/URL\n * - https://caniuse.com/url\n * - https://www.rfc-editor.org/rfc/rfc3986#appendix-B\n *\n * History of the parse() method:\n * - first commit: https://github.com/socketio/socket.io-client/commit/4ee1d5d94b3906a9c052b459f1a818b15f38f91c\n * - export into its own module: https://github.com/socketio/engine.io-client/commit/de2c561e4564efeb78f1bdb1ba39ef81b2822cb3\n * - reimport: https://github.com/socketio/engine.io-client/commit/df32277c3f6d622eec5ed09f493cae3f3391d242\n *\n * @author Steven Levithan <stevenlevithan.com> (MIT license)\n * @api private\n */\nconst re = /^(?:(?![^:@\\/?#]+:[^:@\\/]*@)(http|https|ws|wss):\\/\\/)?((?:(([^:@\\/?#]*)(?::([^:@\\/?#]*))?)?@)?((?:[a-f0-9]{0,4}:){2,7}[a-f0-9]{0,4}|[^:\\/?#]*)(?::(\\d*))?)(((\\/(?:[^?#](?![^?#\\/]*\\.[^?#\\/.]+(?:[?#]|$)))*\\/?)?([^?#\\/]*))(?:\\?([^#]*))?(?:#(.*))?)/;\nconst parts = [\n    'source', 'protocol', 'authority', 'userInfo', 'user', 'password', 'host', 'port', 'relative', 'path', 'directory', 'file', 'query', 'anchor'\n];\nexport function parse(str) {\n    if (str.length > 8000) {\n        throw \"URI too long\";\n    }\n    const src = str, b = str.indexOf('['), e = str.indexOf(']');\n    if (b != -1 && e != -1) {\n        str = str.substring(0, b) + str.substring(b, e).replace(/:/g, ';') + str.substring(e, str.length);\n    }\n    let m = re.exec(str || ''), uri = {}, i = 14;\n    while (i--) {\n        uri[parts[i]] = m[i] || '';\n    }\n    if (b != -1 && e != -1) {\n        uri.source = src;\n        uri.host = uri.host.substring(1, uri.host.length - 1).replace(/;/g, ':');\n        uri.authority = uri.authority.replace('[', '').replace(']', '').replace(/;/g, ':');\n        uri.ipv6uri = true;\n    }\n    uri.pathNames = pathNames(uri, uri['path']);\n    uri.queryKey = queryKey(uri, uri['query']);\n    return uri;\n}\nfunction pathNames(obj, path) {\n    const regx = /\\/{2,9}/g, names = path.replace(regx, \"/\").split(\"/\");\n    if (path.slice(0, 1) == '/' || path.length === 0) {\n        names.splice(0, 1);\n    }\n    if (path.slice(-1) == '/') {\n        names.splice(names.length - 1, 1);\n    }\n    return names;\n}\nfunction queryKey(uri, query) {\n    const data = {};\n    query.replace(/(?:^|&)([^&=]*)=?([^&]*)/g, function ($0, $1, $2) {\n        if ($1) {\n            data[$1] = $2;\n        }\n    });\n    return data;\n}\n","import { transports as DEFAULT_TRANSPORTS } from \"./transports/index.js\";\nimport { installTimerFunctions, byteLength } from \"./util.js\";\nimport { decode } from \"./contrib/parseqs.js\";\nimport { parse } from \"./contrib/parseuri.js\";\nimport { Emitter } from \"@socket.io/component-emitter\";\nimport { protocol } from \"engine.io-parser\";\nimport { createCookieJar, defaultBinaryType, nextTick, } from \"./globals.node.js\";\nconst withEventListeners = typeof addEventListener === \"function\" &&\n    typeof removeEventListener === \"function\";\nconst OFFLINE_EVENT_LISTENERS = [];\nif (withEventListeners) {\n    // within a ServiceWorker, any event handler for the 'offline' event must be added on the initial evaluation of the\n    // script, so we create one single event listener here which will forward the event to the socket instances\n    addEventListener(\"offline\", () => {\n        OFFLINE_EVENT_LISTENERS.forEach((listener) => listener());\n    }, false);\n}\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes without upgrade mechanism, which means that it will keep the first low-level transport that\n * successfully establishes the connection.\n *\n * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.\n *\n * @example\n * import { SocketWithoutUpgrade, WebSocket } from \"engine.io-client\";\n *\n * const socket = new SocketWithoutUpgrade({\n *   transports: [WebSocket]\n * });\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithUpgrade\n * @see Socket\n */\nexport class SocketWithoutUpgrade extends Emitter {\n    /**\n     * Socket constructor.\n     *\n     * @param {String|Object} uri - uri or options\n     * @param {Object} opts - options\n     */\n    constructor(uri, opts) {\n        super();\n        this.binaryType = defaultBinaryType;\n        this.writeBuffer = [];\n        this._prevBufferLen = 0;\n        this._pingInterval = -1;\n        this._pingTimeout = -1;\n        this._maxPayload = -1;\n        /**\n         * The expiration timestamp of the {@link _pingTimeoutTimer} object is tracked, in case the timer is throttled and the\n         * callback is not fired on time. This can happen for example when a laptop is suspended or when a phone is locked.\n         */\n        this._pingTimeoutTime = Infinity;\n        if (uri && \"object\" === typeof uri) {\n            opts = uri;\n            uri = null;\n        }\n        if (uri) {\n            const parsedUri = parse(uri);\n            opts.hostname = parsedUri.host;\n            opts.secure =\n                parsedUri.protocol === \"https\" || parsedUri.protocol === \"wss\";\n            opts.port = parsedUri.port;\n            if (parsedUri.query)\n                opts.query = parsedUri.query;\n        }\n        else if (opts.host) {\n            opts.hostname = parse(opts.host).host;\n        }\n        installTimerFunctions(this, opts);\n        this.secure =\n            null != opts.secure\n                ? opts.secure\n                : typeof location !== \"undefined\" && \"https:\" === location.protocol;\n        if (opts.hostname && !opts.port) {\n            // if no port is specified manually, use the protocol default\n            opts.port = this.secure ? \"443\" : \"80\";\n        }\n        this.hostname =\n            opts.hostname ||\n                (typeof location !== \"undefined\" ? location.hostname : \"localhost\");\n        this.port =\n            opts.port ||\n                (typeof location !== \"undefined\" && location.port\n                    ? location.port\n                    : this.secure\n                        ? \"443\"\n                        : \"80\");\n        this.transports = [];\n        this._transportsByName = {};\n        opts.transports.forEach((t) => {\n            const transportName = t.prototype.name;\n            this.transports.push(transportName);\n            this._transportsByName[transportName] = t;\n        });\n        this.opts = Object.assign({\n            path: \"/engine.io\",\n            agent: false,\n            withCredentials: false,\n            upgrade: true,\n            timestampParam: \"t\",\n            rememberUpgrade: false,\n            addTrailingSlash: true,\n            rejectUnauthorized: true,\n            perMessageDeflate: {\n                threshold: 1024,\n            },\n            transportOptions: {},\n            closeOnBeforeunload: false,\n        }, opts);\n        this.opts.path =\n            this.opts.path.replace(/\\/$/, \"\") +\n                (this.opts.addTrailingSlash ? \"/\" : \"\");\n        if (typeof this.opts.query === \"string\") {\n            this.opts.query = decode(this.opts.query);\n        }\n        if (withEventListeners) {\n            if (this.opts.closeOnBeforeunload) {\n                // Firefox closes the connection when the \"beforeunload\" event is emitted but not Chrome. This event listener\n                // ensures every browser behaves the same (no \"disconnect\" event at the Socket.IO level when the page is\n                // closed/reloaded)\n                this._beforeunloadEventListener = () => {\n                    if (this.transport) {\n                        // silently close the transport\n                        this.transport.removeAllListeners();\n                        this.transport.close();\n                    }\n                };\n                addEventListener(\"beforeunload\", this._beforeunloadEventListener, false);\n            }\n            if (this.hostname !== \"localhost\") {\n                this._offlineEventListener = () => {\n                    this._onClose(\"transport close\", {\n                        description: \"network connection lost\",\n                    });\n                };\n                OFFLINE_EVENT_LISTENERS.push(this._offlineEventListener);\n            }\n        }\n        if (this.opts.withCredentials) {\n            this._cookieJar = createCookieJar();\n        }\n        this._open();\n    }\n    /**\n     * Creates transport of the given type.\n     *\n     * @param {String} name - transport name\n     * @return {Transport}\n     * @private\n     */\n    createTransport(name) {\n        const query = Object.assign({}, this.opts.query);\n        // append engine.io protocol identifier\n        query.EIO = protocol;\n        // transport name\n        query.transport = name;\n        // session id if we already have one\n        if (this.id)\n            query.sid = this.id;\n        const opts = Object.assign({}, this.opts, {\n            query,\n            socket: this,\n            hostname: this.hostname,\n            secure: this.secure,\n            port: this.port,\n        }, this.opts.transportOptions[name]);\n        return new this._transportsByName[name](opts);\n    }\n    /**\n     * Initializes transport to use and starts probe.\n     *\n     * @private\n     */\n    _open() {\n        if (this.transports.length === 0) {\n            // Emit error on next tick so it can be listened to\n            this.setTimeoutFn(() => {\n                this.emitReserved(\"error\", \"No transports available\");\n            }, 0);\n            return;\n        }\n        const transportName = this.opts.rememberUpgrade &&\n            SocketWithoutUpgrade.priorWebsocketSuccess &&\n            this.transports.indexOf(\"websocket\") !== -1\n            ? \"websocket\"\n            : this.transports[0];\n        this.readyState = \"opening\";\n        const transport = this.createTransport(transportName);\n        transport.open();\n        this.setTransport(transport);\n    }\n    /**\n     * Sets the current transport. Disables the existing one (if any).\n     *\n     * @private\n     */\n    setTransport(transport) {\n        if (this.transport) {\n            this.transport.removeAllListeners();\n        }\n        // set up transport\n        this.transport = transport;\n        // set up transport listeners\n        transport\n            .on(\"drain\", this._onDrain.bind(this))\n            .on(\"packet\", this._onPacket.bind(this))\n            .on(\"error\", this._onError.bind(this))\n            .on(\"close\", (reason) => this._onClose(\"transport close\", reason));\n    }\n    /**\n     * Called when connection is deemed open.\n     *\n     * @private\n     */\n    onOpen() {\n        this.readyState = \"open\";\n        SocketWithoutUpgrade.priorWebsocketSuccess =\n            \"websocket\" === this.transport.name;\n        this.emitReserved(\"open\");\n        this.flush();\n    }\n    /**\n     * Handles a packet.\n     *\n     * @private\n     */\n    _onPacket(packet) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            this.emitReserved(\"packet\", packet);\n            // Socket is live - any packet counts\n            this.emitReserved(\"heartbeat\");\n            switch (packet.type) {\n                case \"open\":\n                    this.onHandshake(JSON.parse(packet.data));\n                    break;\n                case \"ping\":\n                    this._sendPacket(\"pong\");\n                    this.emitReserved(\"ping\");\n                    this.emitReserved(\"pong\");\n                    this._resetPingTimeout();\n                    break;\n                case \"error\":\n                    const err = new Error(\"server error\");\n                    // @ts-ignore\n                    err.code = packet.data;\n                    this._onError(err);\n                    break;\n                case \"message\":\n                    this.emitReserved(\"data\", packet.data);\n                    this.emitReserved(\"message\", packet.data);\n                    break;\n            }\n        }\n        else {\n        }\n    }\n    /**\n     * Called upon handshake completion.\n     *\n     * @param {Object} data - handshake obj\n     * @private\n     */\n    onHandshake(data) {\n        this.emitReserved(\"handshake\", data);\n        this.id = data.sid;\n        this.transport.query.sid = data.sid;\n        this._pingInterval = data.pingInterval;\n        this._pingTimeout = data.pingTimeout;\n        this._maxPayload = data.maxPayload;\n        this.onOpen();\n        // In case open handler closes socket\n        if (\"closed\" === this.readyState)\n            return;\n        this._resetPingTimeout();\n    }\n    /**\n     * Sets and resets ping timeout timer based on server pings.\n     *\n     * @private\n     */\n    _resetPingTimeout() {\n        this.clearTimeoutFn(this._pingTimeoutTimer);\n        const delay = this._pingInterval + this._pingTimeout;\n        this._pingTimeoutTime = Date.now() + delay;\n        this._pingTimeoutTimer = this.setTimeoutFn(() => {\n            this._onClose(\"ping timeout\");\n        }, delay);\n        if (this.opts.autoUnref) {\n            this._pingTimeoutTimer.unref();\n        }\n    }\n    /**\n     * Called on `drain` event\n     *\n     * @private\n     */\n    _onDrain() {\n        this.writeBuffer.splice(0, this._prevBufferLen);\n        // setting prevBufferLen = 0 is very important\n        // for example, when upgrading, upgrade packet is sent over,\n        // and a nonzero prevBufferLen could cause problems on `drain`\n        this._prevBufferLen = 0;\n        if (0 === this.writeBuffer.length) {\n            this.emitReserved(\"drain\");\n        }\n        else {\n            this.flush();\n        }\n    }\n    /**\n     * Flush write buffers.\n     *\n     * @private\n     */\n    flush() {\n        if (\"closed\" !== this.readyState &&\n            this.transport.writable &&\n            !this.upgrading &&\n            this.writeBuffer.length) {\n            const packets = this._getWritablePackets();\n            this.transport.send(packets);\n            // keep track of current length of writeBuffer\n            // splice writeBuffer and callbackBuffer on `drain`\n            this._prevBufferLen = packets.length;\n            this.emitReserved(\"flush\");\n        }\n    }\n    /**\n     * Ensure the encoded size of the writeBuffer is below the maxPayload value sent by the server (only for HTTP\n     * long-polling)\n     *\n     * @private\n     */\n    _getWritablePackets() {\n        const shouldCheckPayloadSize = this._maxPayload &&\n            this.transport.name === \"polling\" &&\n            this.writeBuffer.length > 1;\n        if (!shouldCheckPayloadSize) {\n            return this.writeBuffer;\n        }\n        let payloadSize = 1; // first packet type\n        for (let i = 0; i < this.writeBuffer.length; i++) {\n            const data = this.writeBuffer[i].data;\n            if (data) {\n                payloadSize += byteLength(data);\n            }\n            if (i > 0 && payloadSize > this._maxPayload) {\n                return this.writeBuffer.slice(0, i);\n            }\n            payloadSize += 2; // separator + packet type\n        }\n        return this.writeBuffer;\n    }\n    /**\n     * Checks whether the heartbeat timer has expired but the socket has not yet been notified.\n     *\n     * Note: this method is private for now because it does not really fit the WebSocket API, but if we put it in the\n     * `write()` method then the message would not be buffered by the Socket.IO client.\n     *\n     * @return {boolean}\n     * @private\n     */\n    /* private */ _hasPingExpired() {\n        if (!this._pingTimeoutTime)\n            return true;\n        const hasExpired = Date.now() > this._pingTimeoutTime;\n        if (hasExpired) {\n            this._pingTimeoutTime = 0;\n            nextTick(() => {\n                this._onClose(\"ping timeout\");\n            }, this.setTimeoutFn);\n        }\n        return hasExpired;\n    }\n    /**\n     * Sends a message.\n     *\n     * @param {String} msg - message.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @return {Socket} for chaining.\n     */\n    write(msg, options, fn) {\n        this._sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    /**\n     * Sends a message. Alias of {@link Socket#write}.\n     *\n     * @param {String} msg - message.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @return {Socket} for chaining.\n     */\n    send(msg, options, fn) {\n        this._sendPacket(\"message\", msg, options, fn);\n        return this;\n    }\n    /**\n     * Sends a packet.\n     *\n     * @param {String} type: packet type.\n     * @param {String} data.\n     * @param {Object} options.\n     * @param {Function} fn - callback function.\n     * @private\n     */\n    _sendPacket(type, data, options, fn) {\n        if (\"function\" === typeof data) {\n            fn = data;\n            data = undefined;\n        }\n        if (\"function\" === typeof options) {\n            fn = options;\n            options = null;\n        }\n        if (\"closing\" === this.readyState || \"closed\" === this.readyState) {\n            return;\n        }\n        options = options || {};\n        options.compress = false !== options.compress;\n        const packet = {\n            type: type,\n            data: data,\n            options: options,\n        };\n        this.emitReserved(\"packetCreate\", packet);\n        this.writeBuffer.push(packet);\n        if (fn)\n            this.once(\"flush\", fn);\n        this.flush();\n    }\n    /**\n     * Closes the connection.\n     */\n    close() {\n        const close = () => {\n            this._onClose(\"forced close\");\n            this.transport.close();\n        };\n        const cleanupAndClose = () => {\n            this.off(\"upgrade\", cleanupAndClose);\n            this.off(\"upgradeError\", cleanupAndClose);\n            close();\n        };\n        const waitForUpgrade = () => {\n            // wait for upgrade to finish since we can't send packets while pausing a transport\n            this.once(\"upgrade\", cleanupAndClose);\n            this.once(\"upgradeError\", cleanupAndClose);\n        };\n        if (\"opening\" === this.readyState || \"open\" === this.readyState) {\n            this.readyState = \"closing\";\n            if (this.writeBuffer.length) {\n                this.once(\"drain\", () => {\n                    if (this.upgrading) {\n                        waitForUpgrade();\n                    }\n                    else {\n                        close();\n                    }\n                });\n            }\n            else if (this.upgrading) {\n                waitForUpgrade();\n            }\n            else {\n                close();\n            }\n        }\n        return this;\n    }\n    /**\n     * Called upon transport error\n     *\n     * @private\n     */\n    _onError(err) {\n        SocketWithoutUpgrade.priorWebsocketSuccess = false;\n        if (this.opts.tryAllTransports &&\n            this.transports.length > 1 &&\n            this.readyState === \"opening\") {\n            this.transports.shift();\n            return this._open();\n        }\n        this.emitReserved(\"error\", err);\n        this._onClose(\"transport error\", err);\n    }\n    /**\n     * Called upon transport close.\n     *\n     * @private\n     */\n    _onClose(reason, description) {\n        if (\"opening\" === this.readyState ||\n            \"open\" === this.readyState ||\n            \"closing\" === this.readyState) {\n            // clear timers\n            this.clearTimeoutFn(this._pingTimeoutTimer);\n            // stop event from firing again for transport\n            this.transport.removeAllListeners(\"close\");\n            // ensure transport won't stay open\n            this.transport.close();\n            // ignore further transport communication\n            this.transport.removeAllListeners();\n            if (withEventListeners) {\n                if (this._beforeunloadEventListener) {\n                    removeEventListener(\"beforeunload\", this._beforeunloadEventListener, false);\n                }\n                if (this._offlineEventListener) {\n                    const i = OFFLINE_EVENT_LISTENERS.indexOf(this._offlineEventListener);\n                    if (i !== -1) {\n                        OFFLINE_EVENT_LISTENERS.splice(i, 1);\n                    }\n                }\n            }\n            // set ready state\n            this.readyState = \"closed\";\n            // clear session id\n            this.id = null;\n            // emit close event\n            this.emitReserved(\"close\", reason, description);\n            // clean buffers after, so users can still\n            // grab the buffers on `close` event\n            this.writeBuffer = [];\n            this._prevBufferLen = 0;\n        }\n    }\n}\nSocketWithoutUpgrade.protocol = protocol;\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes with an upgrade mechanism, which means that once the connection is established with the first\n * low-level transport, it will try to upgrade to a better transport.\n *\n * In order to allow tree-shaking, there are no transports included, that's why the `transports` option is mandatory.\n *\n * @example\n * import { SocketWithUpgrade, WebSocket } from \"engine.io-client\";\n *\n * const socket = new SocketWithUpgrade({\n *   transports: [WebSocket]\n * });\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithoutUpgrade\n * @see Socket\n */\nexport class SocketWithUpgrade extends SocketWithoutUpgrade {\n    constructor() {\n        super(...arguments);\n        this._upgrades = [];\n    }\n    onOpen() {\n        super.onOpen();\n        if (\"open\" === this.readyState && this.opts.upgrade) {\n            for (let i = 0; i < this._upgrades.length; i++) {\n                this._probe(this._upgrades[i]);\n            }\n        }\n    }\n    /**\n     * Probes a transport.\n     *\n     * @param {String} name - transport name\n     * @private\n     */\n    _probe(name) {\n        let transport = this.createTransport(name);\n        let failed = false;\n        SocketWithoutUpgrade.priorWebsocketSuccess = false;\n        const onTransportOpen = () => {\n            if (failed)\n                return;\n            transport.send([{ type: \"ping\", data: \"probe\" }]);\n            transport.once(\"packet\", (msg) => {\n                if (failed)\n                    return;\n                if (\"pong\" === msg.type && \"probe\" === msg.data) {\n                    this.upgrading = true;\n                    this.emitReserved(\"upgrading\", transport);\n                    if (!transport)\n                        return;\n                    SocketWithoutUpgrade.priorWebsocketSuccess =\n                        \"websocket\" === transport.name;\n                    this.transport.pause(() => {\n                        if (failed)\n                            return;\n                        if (\"closed\" === this.readyState)\n                            return;\n                        cleanup();\n                        this.setTransport(transport);\n                        transport.send([{ type: \"upgrade\" }]);\n                        this.emitReserved(\"upgrade\", transport);\n                        transport = null;\n                        this.upgrading = false;\n                        this.flush();\n                    });\n                }\n                else {\n                    const err = new Error(\"probe error\");\n                    // @ts-ignore\n                    err.transport = transport.name;\n                    this.emitReserved(\"upgradeError\", err);\n                }\n            });\n        };\n        function freezeTransport() {\n            if (failed)\n                return;\n            // Any callback called by transport should be ignored since now\n            failed = true;\n            cleanup();\n            transport.close();\n            transport = null;\n        }\n        // Handle any error that happens while probing\n        const onerror = (err) => {\n            const error = new Error(\"probe error: \" + err);\n            // @ts-ignore\n            error.transport = transport.name;\n            freezeTransport();\n            this.emitReserved(\"upgradeError\", error);\n        };\n        function onTransportClose() {\n            onerror(\"transport closed\");\n        }\n        // When the socket is closed while we're probing\n        function onclose() {\n            onerror(\"socket closed\");\n        }\n        // When the socket is upgraded while we're probing\n        function onupgrade(to) {\n            if (transport && to.name !== transport.name) {\n                freezeTransport();\n            }\n        }\n        // Remove all listeners on the transport and on self\n        const cleanup = () => {\n            transport.removeListener(\"open\", onTransportOpen);\n            transport.removeListener(\"error\", onerror);\n            transport.removeListener(\"close\", onTransportClose);\n            this.off(\"close\", onclose);\n            this.off(\"upgrading\", onupgrade);\n        };\n        transport.once(\"open\", onTransportOpen);\n        transport.once(\"error\", onerror);\n        transport.once(\"close\", onTransportClose);\n        this.once(\"close\", onclose);\n        this.once(\"upgrading\", onupgrade);\n        if (this._upgrades.indexOf(\"webtransport\") !== -1 &&\n            name !== \"webtransport\") {\n            // favor WebTransport\n            this.setTimeoutFn(() => {\n                if (!failed) {\n                    transport.open();\n                }\n            }, 200);\n        }\n        else {\n            transport.open();\n        }\n    }\n    onHandshake(data) {\n        this._upgrades = this._filterUpgrades(data.upgrades);\n        super.onHandshake(data);\n    }\n    /**\n     * Filters upgrades, returning only those matching client transports.\n     *\n     * @param {Array} upgrades - server upgrades\n     * @private\n     */\n    _filterUpgrades(upgrades) {\n        const filteredUpgrades = [];\n        for (let i = 0; i < upgrades.length; i++) {\n            if (~this.transports.indexOf(upgrades[i]))\n                filteredUpgrades.push(upgrades[i]);\n        }\n        return filteredUpgrades;\n    }\n}\n/**\n * This class provides a WebSocket-like interface to connect to an Engine.IO server. The connection will be established\n * with one of the available low-level transports, like HTTP long-polling, WebSocket or WebTransport.\n *\n * This class comes with an upgrade mechanism, which means that once the connection is established with the first\n * low-level transport, it will try to upgrade to a better transport.\n *\n * @example\n * import { Socket } from \"engine.io-client\";\n *\n * const socket = new Socket();\n *\n * socket.on(\"open\", () => {\n *   socket.send(\"hello\");\n * });\n *\n * @see SocketWithoutUpgrade\n * @see SocketWithUpgrade\n */\nexport class Socket extends SocketWithUpgrade {\n    constructor(uri, opts = {}) {\n        const o = typeof uri === \"object\" ? uri : opts;\n        if (!o.transports ||\n            (o.transports && typeof o.transports[0] === \"string\")) {\n            o.transports = (o.transports || [\"polling\", \"websocket\", \"webtransport\"])\n                .map((transportName) => DEFAULT_TRANSPORTS[transportName])\n                .filter((t) => !!t);\n        }\n        super(uri, o);\n    }\n}\n"],"names":["StyleSheet","options","_this","this","_insertTag","tag","before","tags","length","insertionPoint","nextSibling","prepend","container","firstChild","insertBefore","push","isSpeedy","undefined","speedy","ctr","nonce","key","_proto","prototype","hydrate","nodes","forEach","insert","rule","document","createElement","setAttribute","appendChild","createTextNode","createStyleElement","sheet","i","styleSheets","ownerNode","sheetForTag","insertRule","cssRules","e","flush","_tag$parentNode","parentNode","removeChild","identifierWithPointTracking","begin","points","index","previous","character","peek","token","next","slice","position","getRules","value","dealloc","parsed","delimit","from","toRules","alloc","fixedElements","WeakMap","compat","element","type","parent","isImplicitRule","column","line","props","charCodeAt","get","set","rules","parentRules","k","j","replace","removeLabel","prefix","hash","WEBKIT","MOZ","MS","strlen","charat","indexof","defaultStylisPlugins","children","callback","DECLARATION","KEYFRAMES","serialize","copy","RULESET","combine","match","createCache","ssrStyles","querySelectorAll","Array","call","node","getAttribute","indexOf","head","_insert","stylisPlugins","inserted","nodesToHydrate","attrib","split","currentSheet","omnipresentPlugins","finalizingPlugins","stringify","rulesheet","serializer","middleware","concat","selector","serialized","shouldCache","styles","compile","cache","name","registered","memoize","fn","Object","create","arg","hoistNonReactStatics","targetComponent","sourceComponent","hoistNonReactStatics$1","EmotionCacheContext","React","HTMLElement","CacheProvider","Provider","__unsafe_useEmotionCache","useContext","withEmotionCache","func","forwardRef","ref","ThemeContext","useTheme","createCacheWithTheme","weakMemoize","outerTheme","theme","_extends","getTheme","ThemeProvider","withTheme","Component","componentName","displayName","WithTheme","_jsx","JSX","hasOwn","hasOwnProperty","typePropName","Insertion","_ref","isStringTag","registerStyles","useInsertionEffectAlwaysWithSyncFallback","insertStyles","Emotion$1","cssProp","css","WrappedComponent","registeredStyles","className","getRegisteredStyles","serializeStyles","newProps","_key2","jsx","args","arguments","apply","argsLength","createElementArgArray","Emotion","_key","createEmotionProps","Global","sheetRef","useInsertionEffectWithLayoutFallback","constructor","rehydrating","querySelector","current","sheetRefCurrent","nextElementSibling","_len","keyframes","insertable","anim","toString","classnames","len","cls","toAdd","isArray","serializedArr","ClassNames","content","cx","_len2","rawClassName","merge","ele","unitlessKeys","animationIterationCount","aspectRatio","borderImageOutset","borderImageSlice","borderImageWidth","boxFlex","boxFlexGroup","boxOrdinalGroup","columnCount","columns","flex","flexGrow","flexPositive","flexShrink","flexNegative","flexOrder","gridRow","gridRowEnd","gridRowSpan","gridRowStart","gridColumn","gridColumnEnd","gridColumnSpan","gridColumnStart","msGridRow","msGridRowSpan","msGridColumn","msGridColumnSpan","fontWeight","lineHeight","opacity","order","orphans","scale","tabSize","widows","zIndex","zoom","WebkitLineClamp","fillOpacity","floodOpacity","stopOpacity","strokeDasharray","strokeDashoffset","strokeMiterlimit","strokeOpacity","strokeWidth","isDevelopment","hyphenateRegex","animationRegex","isCustomProperty","property","isProcessableValue","processStyleName","styleName","toLowerCase","processStyleValue","p1","p2","cursor","unitless","noComponentSelectorMessage","handleInterpolation","mergedProps","interpolation","componentSelector","__emotion_styles","serializedStyles","obj","string","asString","Error","interpolated","_i","createStringFromObject","previousCursor","result","cached","labelPattern","stringMode","strings","raw","lastIndex","identifierName","exec","str","h","hashString","reactPropsRegex","testOmitPropsOnStringTag","prop","test","testOmitPropsOnComponent","getDefaultShouldForwardProp","composeShouldForwardProps","isReal","shouldForwardProp","optionsShouldForwardProp","__emotion_forwardProp","propName","newStyled","createStyled","targetClassName","__emotion_real","baseTag","__emotion_base","label","target","defaultShouldForwardProp","shouldUseAs","templateStringsArr","Styled","FinalTag","as","classInterpolations","finalShouldForwardProp","defaultProps","defineProperty","withComponent","nextTag","nextOptions","bind","tagName","useInsertionEffect","classNames","has","ret","isRecord","subject","isObject","areOptionsEqual","optionsA","optionsB","optionsAKeys","keys","optionsBKeys","JSON","breakpoints","every","valueA","valueB","sortAndMapPluginToOptions","plugins","sort","a","b","map","plugin","isNumber","isString","isBoolean","mathAbs","n","Math","abs","mathSign","sign","deltaAbs","arrayKeys","array","objectKeys","Number","arrayLast","arrayLastIndex","max","arrayIsLastIndex","arrayFromNumber","startAt","_","object","objectsMergeDeep","objectA","objectB","reduce","mergedObjects","currentObject","areObjects","isMouseEvent","evt","ownerWindow","MouseEvent","EventStore","listeners","self","add","handler","removeListener","passive","addEventListener","removeEventListener","legacyMediaQueryList","addListener","clear","filter","remove","Animations","ownerDocument","update","render","documentVisibleHandler","fixedTimeStep","lastTimeStamp","accumulatedTime","animationId","animate","timeStamp","timeElapsed","requestAnimationFrame","stop","cancelAnimationFrame","init","hidden","destroy","start","Limit","min","reachedMin","reachedMax","reachedAny","constrain","removeOffset","ceil","Counter","loop","loopEnd","counter","withinLimit","clone","DragHandler","axis","rootNode","dragTracker","location","animation","scrollTo","scrollBody","scrollTarget","eventHandler","percentOfView","dragFree","dragThreshold","skipSnaps","baseFriction","watchDrag","cross","crossAxis","direction","focusNodes","nonPassiveEvent","initEvents","dragEvents","goToNextThreshold","measure","snapForceBoost","mouse","touch","freeForceBoost","baseSpeed","isMoving","startScroll","startCross","pointerIsDown","preventScroll","preventClick","isMouse","move","touches","up","lastScroll","readPoint","lastCross","diffScroll","diffCross","cancelable","diff","pointerMove","useFriction","useDuration","preventDefault","targetChanged","byDistance","rawForce","pointerUp","force","baseForce","distance","byIndex","allowedForce","forceFactor","factorAbs","speed","friction","emit","click","stopPropagation","emblaApi","downIfAllowed","isMouseEvt","buttons","button","nodeName","includes","isFocusNode","pointerDown","addDragEvents","down","DragTracker","startEvent","lastEvent","readTime","evtAxis","scroll","coord","expired","diffDrag","diffTime","ResizeHandler","slides","watchResize","nodeRects","observeNodes","resizeObserver","containerSize","slideSizes","destroyed","readSize","measureSize","ResizeObserver","entries","entry","isContainer","slideIndex","lastSize","reInit","defaultCallback","observe","disconnect","ScrollBounds","limit","pullBackThreshold","edgeOffsetTolerance","frictionLimit","disabled","shouldConstrain","edge","diffToEdge","diffToTarget","subtract","useBaseFriction","toggleActive","active","ScrollLooper","contentSize","vectors","shouldLoop","loopDistance","v","ScrollTarget","scrollSnaps","targetVector","minDistance","distances","shortcut","targets","matchingTargets","t","snap","targetSnapDistance","ascDiffsToSnaps","d1","d2","findTargetSnap","reachedBound","SlideFocus","root","slideRegistry","eventStore","watchFocus","focusListenerOptions","capture","lastTabPressTime","registerTabPress","event","code","Date","getTime","slide","scrollLeft","group","findIndex","Vector1D","initialValue","normalizeInput","Translate","translate","containerStyle","style","previousTarget","transform","removeAttribute","to","newTarget","num","round","SlideLooper","viewSize","slideSizesWithGaps","snaps","ascItems","descItems","reverse","loopPoints","gap","findLoopPoints","slidesInGap","startPoints","endPoints","removeSlideSizes","indexes","offset","isEndEdge","slideBounds","end","findSlideBounds","initial","altered","boundEdge","loopPoint","slideLocation","canLoop","shiftLocation","SlidesHandler","watchSlides","mutationObserver","MutationObserver","mutations","mutation","childList","SlidesInView","threshold","intersectionEntryMap","intersectionObserver","inViewCache","notInViewCache","IntersectionObserver","parentElement","inView","slideIndexes","list","parseInt","isIntersecting","createInViewList","SlidesToScroll","slidesToScroll","containerRect","slideRects","startGap","endGap","pixelTolerance","startEdge","endEdge","groupByNumber","groupSlides","groupSize","byNumber","groups","rectB","rectA","isFirst","isLast","edgeA","edgeB","gapA","chunkSize","currentSize","previousSize","bySize","Engine","align","scrollAxis","startIndex","duration","inViewThreshold","containScroll","offsetTop","offsetLeft","offsetWidth","offsetHeight","top","right","bottom","left","width","height","contentDirection","isRightToLeft","isVertical","nodeRect","Axis","PercentOfView","alignment","predefined","center","Alignment","containSnaps","readEdgeGap","withEdgeGap","slideRect","measureStartGap","getComputedStyle","parseFloat","getPropertyValue","measureEndGap","rect","rects","SlideSizes","snapsAligned","alignments","g","ScrollSnaps","snapsContained","scrollContainLimit","scrollBounds","snapsBounded","snapAligned","usePixelTolerance","scrollBound","toFixed","startSnap","endSnap","lastIndexOf","findScrollContainLimit","bound","measureContained","ScrollContain","ScrollLimit","indexPrevious","_ref2","dragHandler","seek","engine","alpha","_ref3","offsetLocation","previousLocation","scrollLooper","slideLooper","shouldSettle","settled","withinBounds","hasSettled","interpolatedLocation","startLocation","baseDuration","scrollVelocity","scrollDirection","scrollDuration","scrollFriction","rawLocation","rawLocationPrevious","velocity","displacement","scrollDistance","useBaseDuration","ScrollBody","indexCurrent","distanceDiff","indexDiff","targetIndex","ScrollTo","scrollProgress","ScrollProgress","slidesInView","groupedSlideIndexes","doNotContain","createSlideRegistry","SlideRegistry","slideFocus","resizeHandler","scrollSnapList","slidesHandler","defaultOptions","OptionsHandler","mergeOptions","optionsAtMedia","matchedMediaOptions","media","matchMedia","matches","mediaOption","optionsMediaQueries","optionsList","acc","mediaQueries","EmblaCarousel","userOptions","userPlugins","defaultView","optionsHandler","pluginsHandler","activePlugins","_ref4","assign","PluginsHandler","mediaHandlers","api","getListeners","off","cb","on","EventHandler","reActivate","pluginApis","optionsBase","globalOptions","pluginList","createEngine","activate","withOptions","withPlugins","userContainer","userSlides","customContainer","customSlides","storeElements","_ref5","query","offsetParent","selectedScrollSnap","deActivate","jump","canScrollNext","canScrollPrev","containerNode","internalEngine","previousScrollSnap","scrollNext","scrollPrev","slideNodes","slidesNotInView","setTimeout","useEmblaCarousel","storedOptions","useRef","storedPlugins","setEmblaApi","useState","viewport","setViewport","useCallback","useEffect","pluginsA","pluginsB","optionA","arePluginsEqual","window","newEmblaApi","PACKET_TYPES","PACKET_TYPES_REVERSE","ERROR_PACKET","data","withNativeBlob","Blob","withNativeArrayBuffer","ArrayBuffer","isView","buffer","encodePacket","supportsBinary","encodeBlobAsBase64","fileReader","FileReader","onload","readAsDataURL","toArray","Uint8Array","byteOffset","byteLength","TEXT_ENCODER","chars","lookup","decodePacket","encodedPacket","binaryType","mapBinary","charAt","decodeBase64Packet","substring","decoded","base64","encoded1","encoded2","encoded3","encoded4","bufferLength","p","arraybuffer","bytes","decode","SEPARATOR","String","fromCharCode","createPacketEncoderStream","TransformStream","packet","controller","arrayBuffer","then","encoded","TextEncoder","encode","encodePacketToBinary","payloadLength","header","DataView","setUint8","view","setUint16","setBigUint64","BigInt","enqueue","TEXT_DECODER","totalLength","chunks","chunk","concatChunks","size","shift","nextTick","Promise","resolve","setTimeoutFn","globalThisShim","Function","pick","attr","NATIVE_SET_TIMEOUT","globalThis","NATIVE_CLEAR_TIMEOUT","clearTimeout","installTimerFunctions","opts","useNativeTimers","clearTimeoutFn","randomString","now","random","TransportError","reason","description","context","super","Transport","Emitter","writable","socket","forceBase64","onError","emitReserved","open","readyState","doOpen","close","doClose","onClose","send","packets","write","onOpen","onData","onPacket","details","pause","onPause","createUri","schema","_hostname","_port","path","_query","hostname","port","secure","encodedQuery","encodeURIComponent","Polling","_polling","_poll","total","once","doPoll","decodePayload","encodedPayload","encodedPackets","decodedPacket","encodePayload","count","join","doWrite","uri","timestampRequests","timestampParam","sid","b64","XMLHttpRequest","err","hasCORS","empty","BaseXHR","isSSL","protocol","xd","req","request","method","xhrStatus","pollXhr","Request","createRequest","_opts","_method","_uri","_data","_create","_a","xdomain","xhr","_xhr","extraHeaders","setDisableHeaderCheck","setRequestHeader","cookieJar","addCookies","withCredentials","requestTimeout","timeout","onreadystatechange","parseCookies","getResponseHeader","status","_onLoad","_onError","_index","requestsCount","requests","_cleanup","fromError","abort","responseText","attachEvent","unloadHandler","hasXHR2","newRequest","responseType","isReactNative","navigator","product","BaseWS","protocols","headers","ws","createSocket","addEventListeners","onopen","autoUnref","_socket","unref","onclose","closeEvent","onmessage","ev","onerror","lastPacket","WebSocketCtor","WebSocket","MozWebSocket","transports","websocket","_packet","webtransport","_transport","WebTransport","transportOptions","closed","catch","ready","createBidirectionalStream","stream","decoderStream","maxPayload","TextDecoder","state","expectedLength","isBinary","headerArray","getUint16","getUint32","pow","createPacketDecoderStream","MAX_SAFE_INTEGER","reader","readable","pipeThrough","getReader","encoderStream","pipeTo","_writer","getWriter","read","done","polling","re","parts","parse","src","m","source","host","authority","ipv6uri","pathNames","regx","names","splice","queryKey","$0","$1","$2","withEventListeners","OFFLINE_EVENT_LISTENERS","listener","SocketWithoutUpgrade","writeBuffer","_prevBufferLen","_pingInterval","_pingTimeout","_maxPayload","_pingTimeoutTime","Infinity","parsedUri","_transportsByName","transportName","agent","upgrade","rememberUpgrade","addTrailingSlash","rejectUnauthorized","perMessageDeflate","closeOnBeforeunload","qs","qry","pairs","l","pair","decodeURIComponent","_beforeunloadEventListener","transport","removeAllListeners","_offlineEventListener","_onClose","_cookieJar","createCookieJar","_open","createTransport","EIO","id","priorWebsocketSuccess","setTransport","_onDrain","_onPacket","onHandshake","_sendPacket","_resetPingTimeout","pingInterval","pingTimeout","_pingTimeoutTimer","delay","upgrading","_getWritablePackets","payloadSize","c","utf8Length","_hasPingExpired","hasExpired","msg","compress","cleanupAndClose","waitForUpgrade","tryAllTransports","SocketWithUpgrade","_upgrades","_probe","failed","onTransportOpen","cleanup","freezeTransport","error","onTransportClose","onupgrade","_filterUpgrades","upgrades","filteredUpgrades","Socket","o","DEFAULT_TRANSPORTS"],"sourceRoot":""}