{"version":3,"file":"main.js","mappings":"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","sources":["webpack://frontend/./node_modules/css-loader/dist/runtime/api.js","webpack://frontend/./node_modules/css-loader/dist/runtime/sourceMaps.js","webpack://frontend/./src/scss/index.scss","webpack://frontend/./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js","webpack://frontend/./node_modules/style-loader/dist/runtime/insertBySelector.js","webpack://frontend/./node_modules/style-loader/dist/runtime/insertStyleElement.js","webpack://frontend/./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js","webpack://frontend/./node_modules/style-loader/dist/runtime/styleDomAPI.js","webpack://frontend/./node_modules/style-loader/dist/runtime/styleTagTransform.js","webpack://frontend/webpack/bootstrap","webpack://frontend/webpack/runtime/compat get default export","webpack://frontend/webpack/runtime/define property getters","webpack://frontend/webpack/runtime/hasOwnProperty shorthand","webpack://frontend/../src/constants.js","webpack://frontend/../src/util.js","webpack://frontend/../src/options.js","webpack://frontend/../src/create-element.js","webpack://frontend/../src/component.js","webpack://frontend/../src/diff/children.js","webpack://frontend/../src/diff/props.js","webpack://frontend/../src/diff/index.js","webpack://frontend/../src/diff/catch-error.js","webpack://frontend/./src/scss/index.scss?7c04","webpack://frontend/../src/index.js","webpack://frontend/../src/PureComponent.js","webpack://frontend/../src/forwardRef.js","webpack://frontend/../src/Children.js","webpack://frontend/../src/suspense.js","webpack://frontend/../src/suspense-list.js","webpack://frontend/../../src/constants.js","webpack://frontend/../src/render.js","webpack://frontend/./src/index.js","webpack://frontend/./assets/svg/whatsapp.svg"],"sourcesContent":["\"use strict\";\n\n/*\n  MIT License http://www.opensource.org/licenses/mit-license.php\n  Author Tobias Koppers @sokra\n*/\nmodule.exports = function (cssWithMappingToString) {\n  var list = []; // return the list of modules as css string\n\n  list.toString = function toString() {\n    return this.map(function (item) {\n      var content = \"\";\n      var needLayer = typeof item[5] !== \"undefined\";\n\n      if (item[4]) {\n        content += \"@supports (\".concat(item[4], \") {\");\n      }\n\n      if (item[2]) {\n        content += \"@media \".concat(item[2], \" {\");\n      }\n\n      if (needLayer) {\n        content += \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\");\n      }\n\n      content += cssWithMappingToString(item);\n\n      if (needLayer) {\n        content += \"}\";\n      }\n\n      if (item[2]) {\n        content += \"}\";\n      }\n\n      if (item[4]) {\n        content += \"}\";\n      }\n\n      return content;\n    }).join(\"\");\n  }; // import a list of modules into the list\n\n\n  list.i = function i(modules, media, dedupe, supports, layer) {\n    if (typeof modules === \"string\") {\n      modules = [[null, modules, undefined]];\n    }\n\n    var alreadyImportedModules = {};\n\n    if (dedupe) {\n      for (var k = 0; k < this.length; k++) {\n        var id = this[k][0];\n\n        if (id != null) {\n          alreadyImportedModules[id] = true;\n        }\n      }\n    }\n\n    for (var _k = 0; _k < modules.length; _k++) {\n      var item = [].concat(modules[_k]);\n\n      if (dedupe && alreadyImportedModules[item[0]]) {\n        continue;\n      }\n\n      if (typeof layer !== \"undefined\") {\n        if (typeof item[5] === \"undefined\") {\n          item[5] = layer;\n        } else {\n          item[1] = \"@layer\".concat(item[5].length > 0 ? \" \".concat(item[5]) : \"\", \" {\").concat(item[1], \"}\");\n          item[5] = layer;\n        }\n      }\n\n      if (media) {\n        if (!item[2]) {\n          item[2] = media;\n        } else {\n          item[1] = \"@media \".concat(item[2], \" {\").concat(item[1], \"}\");\n          item[2] = media;\n        }\n      }\n\n      if (supports) {\n        if (!item[4]) {\n          item[4] = \"\".concat(supports);\n        } else {\n          item[1] = \"@supports (\".concat(item[4], \") {\").concat(item[1], \"}\");\n          item[4] = supports;\n        }\n      }\n\n      list.push(item);\n    }\n  };\n\n  return list;\n};","\"use strict\";\n\nmodule.exports = function (item) {\n  var content = item[1];\n  var cssMapping = item[3];\n\n  if (!cssMapping) {\n    return content;\n  }\n\n  if (typeof btoa === \"function\") {\n    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));\n    var data = \"sourceMappingURL=data:application/json;charset=utf-8;base64,\".concat(base64);\n    var sourceMapping = \"/*# \".concat(data, \" */\");\n    var sourceURLs = cssMapping.sources.map(function (source) {\n      return \"/*# sourceURL=\".concat(cssMapping.sourceRoot || \"\").concat(source, \" */\");\n    });\n    return [content].concat(sourceURLs).concat([sourceMapping]).join(\"\\n\");\n  }\n\n  return [content].join(\"\\n\");\n};","// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/sourceMaps.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, \"button{background:none;border:none;cursor:pointer}nav{margin:0;padding:0;list-style:none}nav ul{margin:0;padding:0;list-style:none}nav li{display:inline;margin-right:20px}h1,h2,h3,h4,h5,h6{margin:0;font-weight:400}a{text-decoration:none;color:inherit}*{box-sizing:border-box;position:relative}html,body{margin:0;padding:0;font-family:\\\"Outfit\\\", sans-serif;font-optical-sizing:auto;font-style:normal;background-color:#00041C;color:white;background:#3A5574;background:linear-gradient(311deg, #3a5574 0%, #3a5574 100%);box-sizing:border-box;width:100%}.Body{display:flex;flex-direction:column;width:100%;flex:1}.Content{width:100%}.Header{padding:20px}.Header .Title{font-size:2rem;margin:0}.Header .Subtitle{font-size:1.2rem;text-transform:uppercase;font-weight:200}.Section.CallToAction .Whatsapp{display:flex;justify-content:center;align-items:center;background-color:white;height:70px;border-radius:40px;gap:15px;padding:0 20px;margin-top:20px}.Section.CallToAction .Whatsapp a{text-decoration:none !important}.Section.CallToAction .Whatsapp__Wrapper{display:flex;justify-content:center;margin-top:20px}.Section.CallToAction .Whatsapp svg{width:40px;fill:#25d366}.Section.CallToAction .Whatsapp .Text{margin-top:0;display:flex;flex-direction:column;justify-content:center;align-items:center;font-size:1.0rem;font-weight:700;color:#25d366}@keyframes rotateClockwise{from{transform:rotate(0deg)}to{transform:rotate(360deg)}}@keyframes rotateCounterClockwise{from{transform:rotate(0deg)}to{transform:rotate(-360deg)}}.Background{position:absolute;left:-50vw;width:300vw}@media (min-width: 768px){.Background{left:initial;width:initial;transform:scale(1.5)}}.Background circle{stroke:white !important;opacity:0.03}header{position:fixed;width:100vw;top:0;background-color:#3A5574;height:130px;border-bottom:1px solid rgba(255,255,255,0.1);z-index:1000000}@media (min-width: 768px){header{height:100px}}.Section{padding:20px;font-size:25px;font-weight:100;padding-top:40px;padding-bottom:40px;background-color:white;color:#3A5574}.Section.Main{padding-top:180px;height:100vh;overflow:hidden;display:flex;flex-direction:column;justify-content:center;align-items:center;background:#3A5574;color:white}.Section.Main .Text{margin-top:0;padding-top:0;font-size:26px}@media (min-width: 768px){.Section.Main{height:70vh}.Section.Main .Text{font-size:2.4rem}}.Section.CallToAction{background:#ccdcee;text-align:center;padding:40px;padding-top:60px;padding-bottom:100px}.Section.CallToAction p a{color:#3A5574;text-decoration:underline;font-weight:500}.Section.CallToAction .Bye{font-size:2.8rem;margin:0;font-weight:500}.Section.CallToAction .Title{font-size:2.5rem;margin:0;font-weight:500}.Section.CallToAction .Text{margin-top:20px;font-size:1.5rem;font-weight:400}@media (min-width: 768px){.Section{padding:30px;padding-top:50px;padding-bottom:50px}}.Section .Title{font-size:1.8rem;margin:0;font-weight:500}.Section .Text{margin-top:20px;font-size:1.5rem;font-weight:300}footer{background-color:#3A5574;color:white;padding:20px;text-align:center;font-size:1.2rem;font-weight:300;border-top:1px solid rgba(255,255,255,0.1)}\\n\", \"\",{\"version\":3,\"sources\":[\"webpack://./src/scss/_reset.scss\",\"webpack://./src/scss/index.scss\"],\"names\":[],\"mappings\":\"AACA,OACE,eAAgB,CAChB,WAAY,CACZ,cAAe,CAChB,IAGC,QAAS,CACT,SAAU,CACV,eAAgB,CAHlB,OAMI,QAAS,CACT,SAAU,CACV,eAAgB,CARpB,OAYI,cAAe,CACf,iBAAkB,CACnB,kBAKD,QAAS,CACT,eAAgB,CACjB,EAGC,oBAAqB,CACrB,aAAc,CACf,EAIC,qBAAsB,CACtB,iBAAkB,CCnCpB,UACE,QAAS,CACT,SAAU,CACV,gCAAiC,CACjC,wBAAyB,CACzB,iBAAkB,CAClB,wBAAyB,CACzB,WAAY,CAEZ,kBAAmB,CACnB,4DAA6E,CAC7E,qBAAsB,CACtB,UAAW,CACZ,MAGC,YAAa,CACb,qBAAsB,CACtB,UAAW,CACX,MAAO,CACR,SAGC,UAAW,CACZ,QAGC,YAAa,CADf,eAII,cAAe,CACf,QAAS,CALb,kBASI,gBAAiB,CACjB,wBAAyB,CACzB,eAAgB,CACjB,gCAID,YAAa,CACb,sBAAuB,CACvB,kBAAmB,CACnB,sBAAuB,CACvB,WAAY,CACZ,kBAAmB,CACnB,QAAS,CACT,cAAe,CACf,eAAgB,CATlB,kCAYI,+BAAgC,CAZpC,yCAgBI,YAAa,CACb,sBAAuB,CACvB,eAAgB,CAlBpB,oCAsBI,UAAW,CACX,YAA2B,CAvB/B,sCA2BI,YAAa,CACb,YAAa,CACb,qBAAsB,CACtB,sBAAuB,CACvB,kBAAmB,CACnB,gBAAiB,CACjB,eAAgB,CAChB,aAA4B,CAC7B,2BAID,KACE,sBAAuB,CAEzB,GACE,wBAAyB,CAAA,CAI7B,kCACE,KACE,sBAAuB,CAEzB,GACE,yBAA0B,CAAA,CAyB9B,YACE,iBAAkB,CAClB,UAAW,CACX,WAAY,CAab,0BAhBD,YAOI,YAAa,CACb,aAAc,CACd,oBAAqB,CAOxB,CAhBD,mBAaI,uBAAwB,CACxB,YAAa,CACd,OAKD,cAAe,CACf,WAAY,CACZ,KAAM,CACN,wBAAyB,CACzB,YAAa,CACb,6CAAiD,CACjD,eAAgB,CAKjB,0BAbD,OAWI,YAAa,CAEhB,CAED,SACE,YAAa,CACb,cAAe,CACf,eAAgB,CAChB,gBAAiB,CACjB,mBAAoB,CACpB,sBAAuB,CACvB,aAAc,CAPhB,cAUI,iBAAkB,CAClB,YAAa,CACb,eAAgB,CAChB,YAAa,CACb,qBAAsB,CACtB,sBAAuB,CACvB,kBAAmB,CACnB,kBAAmB,CACnB,WAAY,CAlBhB,oBAqBM,YAAa,CACb,aAAc,CACd,cAAe,CAChB,0BAxBL,cA2BM,WAAY,CA3BlB,oBA8BQ,gBAAiB,CAClB,CA/BP,sBAoCI,kBAAmB,CACnB,iBAAkB,CAClB,YAAa,CACb,gBAAiB,CACjB,oBAAqB,CAxCzB,0BA4CQ,aAAc,CACd,yBAA0B,CAC1B,eAAgB,CA9CxB,2BAmDM,gBAAiB,CACjB,QAAS,CACT,eAAgB,CArDtB,6BA0DM,gBAAiB,CACjB,QAAS,CACT,eAAgB,CA5DtB,4BAgEM,eAAgB,CAChB,gBAAiB,CACjB,eAAgB,CAGjB,0BArEL,SAyEI,YAAa,CACb,gBAAiB,CACjB,mBAAoB,CAcvB,CAzFD,gBA+EI,gBAAiB,CACjB,QAAS,CACT,eAAgB,CAjFpB,eAqFI,eAAgB,CAChB,gBAAiB,CACjB,eAAgB,CACjB,OAID,wBAAyB,CACzB,WAAY,CACZ,YAAa,CACb,iBAAkB,CAClB,gBAAiB,CACjB,eAAgB,CAChB,0CAA8C\",\"sourcesContent\":[\"//reset\\r\\nbutton {\\r\\n  background: none;\\r\\n  border: none;\\r\\n  cursor: pointer;\\r\\n}\\r\\n\\r\\nnav {\\r\\n  margin: 0;\\r\\n  padding: 0;\\r\\n  list-style: none;\\r\\n\\r\\n  ul {\\r\\n    margin: 0;\\r\\n    padding: 0;\\r\\n    list-style: none;\\r\\n  }\\r\\n\\r\\n  li {\\r\\n    display: inline;\\r\\n    margin-right: 20px;\\r\\n  }\\r\\n}\\r\\n\\r\\n\\r\\nh1, h2, h3, h4, h5, h6 {\\r\\n  margin: 0;\\r\\n  font-weight: 400;\\r\\n}\\r\\n\\r\\na {\\r\\n  text-decoration: none;\\r\\n  color: inherit;\\r\\n}\\r\\n\\r\\n\\r\\n* {\\r\\n  box-sizing: border-box;\\r\\n  position: relative;\\r\\n}\\r\\n\\r\\n\",\"@import 'mixins';\\r\\n@import 'reset';\\r\\n\\r\\nhtml, body {\\r\\n  margin: 0;\\r\\n  padding: 0;\\r\\n  font-family: \\\"Outfit\\\", sans-serif;\\r\\n  font-optical-sizing: auto;\\r\\n  font-style: normal;\\r\\n  background-color: #00041C;\\r\\n  color: white;\\r\\n\\r\\n  background: #3A5574;\\r\\n  background: linear-gradient(311deg, rgba(#3A5574,1) 0%, rgba(#3A5574,1) 100%);\\r\\n  box-sizing: border-box;\\r\\n  width: 100%;\\r\\n}\\r\\n\\r\\n.Body {\\r\\n  display: flex;\\r\\n  flex-direction: column;\\r\\n  width: 100%;\\r\\n  flex: 1;\\r\\n}\\r\\n\\r\\n.Content {\\r\\n  width: 100%;\\r\\n}\\r\\n\\r\\n.Header {\\r\\n  padding: 20px;\\r\\n\\r\\n  .Title {\\r\\n    font-size: 2rem;\\r\\n    margin: 0;\\r\\n  }\\r\\n\\r\\n  .Subtitle {\\r\\n    font-size: 1.2rem;\\r\\n    text-transform: uppercase;\\r\\n    font-weight: 200;\\r\\n  }\\r\\n}\\r\\n\\r\\n.Section.CallToAction .Whatsapp {\\r\\n  display: flex;\\r\\n  justify-content: center;\\r\\n  align-items: center;\\r\\n  background-color: white;\\r\\n  height: 70px;\\r\\n  border-radius: 40px;\\r\\n  gap: 15px;\\r\\n  padding: 0 20px;\\r\\n  margin-top: 20px;\\r\\n  \\r\\n  a {\\r\\n    text-decoration: none !important;\\r\\n  }\\r\\n\\r\\n  &__Wrapper {\\r\\n    display: flex;\\r\\n    justify-content: center; \\r\\n    margin-top: 20px;   \\r\\n  }\\r\\n\\r\\n  svg {\\r\\n    width: 40px;\\r\\n    fill: rgba(37,211,102, 1.0);\\r\\n  }\\r\\n\\r\\n  .Text {\\r\\n    margin-top: 0;\\r\\n    display: flex;\\r\\n    flex-direction: column;\\r\\n    justify-content: center;\\r\\n    align-items: center;\\r\\n    font-size: 1.0rem;\\r\\n    font-weight: 700;\\r\\n    color: rgba(37,211,102, 1.0)\\r\\n  }\\r\\n}\\r\\n\\r\\n@keyframes rotateClockwise {\\r\\n  from {\\r\\n    transform: rotate(0deg);\\r\\n  }\\r\\n  to {\\r\\n    transform: rotate(360deg);\\r\\n  }\\r\\n}\\r\\n\\r\\n@keyframes rotateCounterClockwise {\\r\\n  from {\\r\\n    transform: rotate(0deg);\\r\\n  }\\r\\n  to {\\r\\n    transform: rotate(-360deg);\\r\\n  }\\r\\n}\\r\\n\\r\\n@mixin randomRotate {\\r\\n  $animations: rotateClockwise, rotateCounterClockwise;\\r\\n  $duration: 5s, 10s, 15s, 20s; // Different durations\\r\\n  $delay: 0s, 2s, 4s, 6s, 8s; // Different start delays\\r\\n  $iteration: infinite;\\r\\n\\r\\n  // Randomly pick an animation\\r\\n  $animation-name: nth($animations, random(length($animations)));\\r\\n  // Randomly pick a duration\\r\\n  $animation-duration: nth($duration, random(length($duration)));\\r\\n  // Randomly pick a delay\\r\\n  $animation-delay: nth($delay, random(length($delay)));\\r\\n\\r\\n  animation-name: $animation-name;\\r\\n  animation-duration: $animation-duration;\\r\\n  animation-timing-function: linear;\\r\\n  animation-delay: $animation-delay;\\r\\n  animation-iteration-count: $iteration;\\r\\n  transform-origin: center;\\r\\n}\\r\\n\\r\\n.Background {\\r\\n  position: absolute;\\r\\n  left: -50vw;\\r\\n  width: 300vw;\\r\\n\\r\\n\\r\\n  @include breakpoint(md) {\\r\\n    left: initial;\\r\\n    width: initial;\\r\\n    transform: scale(1.5);\\r\\n  }\\r\\n\\r\\n  circle {\\r\\n    stroke: white !important;\\r\\n    opacity: 0.03;\\r\\n  }\\r\\n}\\r\\n\\r\\nheader {\\r\\n  //make header sticky\\r\\n  position: fixed;\\r\\n  width: 100vw;\\r\\n  top: 0;\\r\\n  background-color: #3A5574;\\r\\n  height: 130px;\\r\\n  border-bottom: 1px solid rgba(255, 255, 255, 0.1);\\r\\n  z-index: 1000000;\\r\\n\\r\\n  @include breakpoint(md) {\\r\\n    height: 100px;\\r\\n  }\\r\\n}\\r\\n\\r\\n.Section {\\r\\n  padding: 20px;\\r\\n  font-size: 25px;\\r\\n  font-weight: 100;\\r\\n  padding-top: 40px;\\r\\n  padding-bottom: 40px;\\r\\n  background-color: white;\\r\\n  color: #3A5574;\\r\\n\\r\\n  &.Main {\\r\\n    padding-top: 180px;\\r\\n    height: 100vh;\\r\\n    overflow: hidden;\\r\\n    display: flex;\\r\\n    flex-direction: column;\\r\\n    justify-content: center;\\r\\n    align-items: center;\\r\\n    background: #3A5574;\\r\\n    color: white;\\r\\n\\r\\n    .Text {\\r\\n      margin-top: 0;\\r\\n      padding-top: 0;\\r\\n      font-size: 26px;\\r\\n    }\\r\\n\\r\\n    @include breakpoint(md) {\\r\\n      height: 70vh;\\r\\n\\r\\n      .Text {\\r\\n        font-size: 2.4rem;\\r\\n      }\\r\\n    }\\r\\n  }\\r\\n\\r\\n  &.CallToAction {\\r\\n    background: #ccdcee;\\r\\n    text-align: center;\\r\\n    padding: 40px;\\r\\n    padding-top: 60px;\\r\\n    padding-bottom: 100px;\\r\\n\\r\\n    p {\\r\\n      a {\\r\\n        color: #3A5574;\\r\\n        text-decoration: underline;\\r\\n        font-weight: 500;\\r\\n      }\\r\\n    }\\r\\n\\r\\n    .Bye {\\r\\n      font-size: 2.8rem;\\r\\n      margin: 0;\\r\\n      font-weight: 500;\\r\\n    }\\r\\n    \\r\\n\\r\\n    .Title {\\r\\n      font-size: 2.5rem;\\r\\n      margin: 0;\\r\\n      font-weight: 500;\\r\\n    }\\r\\n\\r\\n    .Text {\\r\\n      margin-top: 20px;\\r\\n      font-size: 1.5rem;\\r\\n      font-weight: 400;\\r\\n\\r\\n      \\r\\n    }\\r\\n  }\\r\\n\\r\\n  @include breakpoint(md) {\\r\\n    padding: 30px;\\r\\n    padding-top: 50px;\\r\\n    padding-bottom: 50px;\\r\\n  }\\r\\n\\r\\n  .Title {\\r\\n    font-size: 1.8rem;\\r\\n    margin: 0;\\r\\n    font-weight: 500;\\r\\n  }\\r\\n\\r\\n  .Text {\\r\\n    margin-top: 20px;\\r\\n    font-size: 1.5rem;\\r\\n    font-weight: 300;\\r\\n  }\\r\\n}\\r\\n\\r\\nfooter {\\r\\n  background-color: #3A5574;\\r\\n  color: white;\\r\\n  padding: 20px;\\r\\n  text-align: center;\\r\\n  font-size: 1.2rem;\\r\\n  font-weight: 300;\\r\\n  border-top: 1px solid rgba(255, 255, 255, 0.1);\\r\\n}\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","\"use strict\";\n\nvar stylesInDOM = [];\n\nfunction getIndexByIdentifier(identifier) {\n  var result = -1;\n\n  for (var i = 0; i < stylesInDOM.length; i++) {\n    if (stylesInDOM[i].identifier === identifier) {\n      result = i;\n      break;\n    }\n  }\n\n  return result;\n}\n\nfunction modulesToDom(list, options) {\n  var idCountMap = {};\n  var identifiers = [];\n\n  for (var i = 0; i < list.length; i++) {\n    var item = list[i];\n    var id = options.base ? item[0] + options.base : item[0];\n    var count = idCountMap[id] || 0;\n    var identifier = \"\".concat(id, \" \").concat(count);\n    idCountMap[id] = count + 1;\n    var indexByIdentifier = getIndexByIdentifier(identifier);\n    var obj = {\n      css: item[1],\n      media: item[2],\n      sourceMap: item[3],\n      supports: item[4],\n      layer: item[5]\n    };\n\n    if (indexByIdentifier !== -1) {\n      stylesInDOM[indexByIdentifier].references++;\n      stylesInDOM[indexByIdentifier].updater(obj);\n    } else {\n      var updater = addElementStyle(obj, options);\n      options.byIndex = i;\n      stylesInDOM.splice(i, 0, {\n        identifier: identifier,\n        updater: updater,\n        references: 1\n      });\n    }\n\n    identifiers.push(identifier);\n  }\n\n  return identifiers;\n}\n\nfunction addElementStyle(obj, options) {\n  var api = options.domAPI(options);\n  api.update(obj);\n\n  var updater = function updater(newObj) {\n    if (newObj) {\n      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {\n        return;\n      }\n\n      api.update(obj = newObj);\n    } else {\n      api.remove();\n    }\n  };\n\n  return updater;\n}\n\nmodule.exports = function (list, options) {\n  options = options || {};\n  list = list || [];\n  var lastIdentifiers = modulesToDom(list, options);\n  return function update(newList) {\n    newList = newList || [];\n\n    for (var i = 0; i < lastIdentifiers.length; i++) {\n      var identifier = lastIdentifiers[i];\n      var index = getIndexByIdentifier(identifier);\n      stylesInDOM[index].references--;\n    }\n\n    var newLastIdentifiers = modulesToDom(newList, options);\n\n    for (var _i = 0; _i < lastIdentifiers.length; _i++) {\n      var _identifier = lastIdentifiers[_i];\n\n      var _index = getIndexByIdentifier(_identifier);\n\n      if (stylesInDOM[_index].references === 0) {\n        stylesInDOM[_index].updater();\n\n        stylesInDOM.splice(_index, 1);\n      }\n    }\n\n    lastIdentifiers = newLastIdentifiers;\n  };\n};","\"use strict\";\n\nvar memo = {};\n/* istanbul ignore next  */\n\nfunction getTarget(target) {\n  if (typeof memo[target] === \"undefined\") {\n    var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself\n\n    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {\n      try {\n        // This will throw an exception if access to iframe is blocked\n        // due to cross-origin restrictions\n        styleTarget = styleTarget.contentDocument.head;\n      } catch (e) {\n        // istanbul ignore next\n        styleTarget = null;\n      }\n    }\n\n    memo[target] = styleTarget;\n  }\n\n  return memo[target];\n}\n/* istanbul ignore next  */\n\n\nfunction insertBySelector(insert, style) {\n  var target = getTarget(insert);\n\n  if (!target) {\n    throw new Error(\"Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.\");\n  }\n\n  target.appendChild(style);\n}\n\nmodule.exports = insertBySelector;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction insertStyleElement(options) {\n  var element = document.createElement(\"style\");\n  options.setAttributes(element, options.attributes);\n  options.insert(element, options.options);\n  return element;\n}\n\nmodule.exports = insertStyleElement;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction setAttributesWithoutAttributes(styleElement) {\n  var nonce = typeof __webpack_nonce__ !== \"undefined\" ? __webpack_nonce__ : null;\n\n  if (nonce) {\n    styleElement.setAttribute(\"nonce\", nonce);\n  }\n}\n\nmodule.exports = setAttributesWithoutAttributes;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction apply(styleElement, options, obj) {\n  var css = \"\";\n\n  if (obj.supports) {\n    css += \"@supports (\".concat(obj.supports, \") {\");\n  }\n\n  if (obj.media) {\n    css += \"@media \".concat(obj.media, \" {\");\n  }\n\n  var needLayer = typeof obj.layer !== \"undefined\";\n\n  if (needLayer) {\n    css += \"@layer\".concat(obj.layer.length > 0 ? \" \".concat(obj.layer) : \"\", \" {\");\n  }\n\n  css += obj.css;\n\n  if (needLayer) {\n    css += \"}\";\n  }\n\n  if (obj.media) {\n    css += \"}\";\n  }\n\n  if (obj.supports) {\n    css += \"}\";\n  }\n\n  var sourceMap = obj.sourceMap;\n\n  if (sourceMap && typeof btoa !== \"undefined\") {\n    css += \"\\n/*# sourceMappingURL=data:application/json;base64,\".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), \" */\");\n  } // For old IE\n\n  /* istanbul ignore if  */\n\n\n  options.styleTagTransform(css, styleElement, options.options);\n}\n\nfunction removeStyleElement(styleElement) {\n  // istanbul ignore if\n  if (styleElement.parentNode === null) {\n    return false;\n  }\n\n  styleElement.parentNode.removeChild(styleElement);\n}\n/* istanbul ignore next  */\n\n\nfunction domAPI(options) {\n  var styleElement = options.insertStyleElement(options);\n  return {\n    update: function update(obj) {\n      apply(styleElement, options, obj);\n    },\n    remove: function remove() {\n      removeStyleElement(styleElement);\n    }\n  };\n}\n\nmodule.exports = domAPI;","\"use strict\";\n\n/* istanbul ignore next  */\nfunction styleTagTransform(css, styleElement) {\n  if (styleElement.styleSheet) {\n    styleElement.styleSheet.cssText = css;\n  } else {\n    while (styleElement.firstChild) {\n      styleElement.removeChild(styleElement.firstChild);\n    }\n\n    styleElement.appendChild(document.createTextNode(css));\n  }\n}\n\nmodule.exports = styleTagTransform;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","/** Normal hydration that attaches to a DOM tree but does not diff it. */\nexport const MODE_HYDRATE = 1 << 5;\n/** Signifies this VNode suspended on the previous render */\nexport const MODE_SUSPENDED = 1 << 7;\n/** Indicates that this node needs to be inserted while patching children */\nexport const INSERT_VNODE = 1 << 16;\n/** Indicates a VNode has been matched with another VNode in the diff */\nexport const MATCHED = 1 << 17;\n\n/** Reset all mode flags */\nexport const RESET_MODE = ~(MODE_HYDRATE | MODE_SUSPENDED);\n\nexport const EMPTY_OBJ = /** @type {any} */ ({});\nexport const EMPTY_ARR = [];\nexport const IS_NON_DIMENSIONAL =\n\t/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\n","import { EMPTY_ARR } from './constants';\n\nexport const isArray = Array.isArray;\n\n/**\n * Assign properties from `props` to `obj`\n * @template O, P The obj and props types\n * @param {O} obj The object to copy properties to\n * @param {P} props The object to copy properties from\n * @returns {O & P}\n */\nexport function assign(obj, props) {\n\t// @ts-expect-error We change the type of `obj` to be `O & P`\n\tfor (let i in props) obj[i] = props[i];\n\treturn /** @type {O & P} */ (obj);\n}\n\n/**\n * Remove a child node from its parent if attached. This is a workaround for\n * IE11 which doesn't support `Element.prototype.remove()`. Using this function\n * is smaller than including a dedicated polyfill.\n * @param {preact.ContainerNode} node The node to remove\n */\nexport function removeNode(node) {\n\tlet parentNode = node.parentNode;\n\tif (parentNode) parentNode.removeChild(node);\n}\n\nexport const slice = EMPTY_ARR.slice;\n","import { _catchError } from './diff/catch-error';\n\n/**\n * The `option` object can potentially contain callback functions\n * that are called during various stages of our renderer. This is the\n * foundation on which all our addons like `preact/debug`, `preact/compat`,\n * and `preact/hooks` are based on. See the `Options` type in `internal.d.ts`\n * for a full list of available option hooks (most editors/IDEs allow you to\n * ctrl+click or cmd+click on mac the type definition below).\n * @type {Options}\n */\nconst options = {\n\t_catchError\n};\n\nexport default options;\n","import { slice } from './util';\nimport options from './options';\n\nlet vnodeId = 0;\n\n/**\n * Create an virtual node (used for JSX)\n * @param {VNode[\"type\"]} type The node name or Component constructor for this\n * virtual node\n * @param {object | null | undefined} [props] The properties of the virtual node\n * @param {Array<import('.').ComponentChildren>} [children] The children of the\n * virtual node\n * @returns {VNode}\n */\nexport function createElement(type, props, children) {\n\tlet normalizedProps = {},\n\t\tkey,\n\t\tref,\n\t\ti;\n\tfor (i in props) {\n\t\tif (i == 'key') key = props[i];\n\t\telse if (i == 'ref') ref = props[i];\n\t\telse normalizedProps[i] = props[i];\n\t}\n\n\tif (arguments.length > 2) {\n\t\tnormalizedProps.children =\n\t\t\targuments.length > 3 ? slice.call(arguments, 2) : children;\n\t}\n\n\t// If a Component VNode, check for and apply defaultProps\n\t// Note: type may be undefined in development, must never error here.\n\tif (typeof type == 'function' && type.defaultProps != null) {\n\t\tfor (i in type.defaultProps) {\n\t\t\tif (normalizedProps[i] === undefined) {\n\t\t\t\tnormalizedProps[i] = type.defaultProps[i];\n\t\t\t}\n\t\t}\n\t}\n\n\treturn createVNode(type, normalizedProps, key, ref, null);\n}\n\n/**\n * Create a VNode (used internally by Preact)\n * @param {VNode[\"type\"]} type The node name or Component\n * Constructor for this virtual node\n * @param {object | string | number | null} props The properties of this virtual node.\n * If this virtual node represents a text node, this is the text of the node (string or number).\n * @param {string | number | null} key The key for this virtual node, used when\n * diffing it against its children\n * @param {VNode[\"ref\"]} ref The ref property that will\n * receive a reference to its created child\n * @returns {VNode}\n */\nexport function createVNode(type, props, key, ref, original) {\n\t// V8 seems to be better at detecting type shapes if the object is allocated from the same call site\n\t// Do not inline into createElement and coerceToVNode!\n\t/** @type {VNode} */\n\tconst vnode = {\n\t\ttype,\n\t\tprops,\n\t\tkey,\n\t\tref,\n\t\t_children: null,\n\t\t_parent: null,\n\t\t_depth: 0,\n\t\t_dom: null,\n\t\t// _nextDom must be initialized to undefined b/c it will eventually\n\t\t// be set to dom.nextSibling which can return `null` and it is important\n\t\t// to be able to distinguish between an uninitialized _nextDom and\n\t\t// a _nextDom that has been set to `null`\n\t\t_nextDom: undefined,\n\t\t_component: null,\n\t\tconstructor: undefined,\n\t\t_original: original == null ? ++vnodeId : original,\n\t\t_index: -1,\n\t\t_flags: 0\n\t};\n\n\t// Only invoke the vnode hook if this was *not* a direct copy:\n\tif (original == null && options.vnode != null) options.vnode(vnode);\n\n\treturn vnode;\n}\n\nexport function createRef() {\n\treturn { current: null };\n}\n\nexport function Fragment(props) {\n\treturn props.children;\n}\n\n/**\n * Check if a the argument is a valid Preact VNode.\n * @param {*} vnode\n * @returns {vnode is VNode}\n */\nexport const isValidElement = vnode =>\n\tvnode != null && vnode.constructor == undefined;\n","import { assign } from './util';\nimport { diff, commitRoot } from './diff/index';\nimport options from './options';\nimport { Fragment } from './create-element';\nimport { MODE_HYDRATE } from './constants';\n\n/**\n * Base Component class. Provides `setState()` and `forceUpdate()`, which\n * trigger rendering\n * @param {object} props The initial component props\n * @param {object} context The initial context from parent components'\n * getChildContext\n */\nexport function BaseComponent(props, context) {\n\tthis.props = props;\n\tthis.context = context;\n}\n\n/**\n * Update component state and schedule a re-render.\n * @this {Component}\n * @param {object | ((s: object, p: object) => object)} update A hash of state\n * properties to update with new values or a function that given the current\n * state and props returns a new partial state\n * @param {() => void} [callback] A function to be called once component state is\n * updated\n */\nBaseComponent.prototype.setState = function (update, callback) {\n\t// only clone state when copying to nextState the first time.\n\tlet s;\n\tif (this._nextState != null && this._nextState !== this.state) {\n\t\ts = this._nextState;\n\t} else {\n\t\ts = this._nextState = assign({}, this.state);\n\t}\n\n\tif (typeof update == 'function') {\n\t\t// Some libraries like `immer` mark the current state as readonly,\n\t\t// preventing us from mutating it, so we need to clone it. See #2716\n\t\tupdate = update(assign({}, s), this.props);\n\t}\n\n\tif (update) {\n\t\tassign(s, update);\n\t}\n\n\t// Skip update if updater function returned null\n\tif (update == null) return;\n\n\tif (this._vnode) {\n\t\tif (callback) {\n\t\t\tthis._stateCallbacks.push(callback);\n\t\t}\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Immediately perform a synchronous re-render of the component\n * @this {Component}\n * @param {() => void} [callback] A function to be called after component is\n * re-rendered\n */\nBaseComponent.prototype.forceUpdate = function (callback) {\n\tif (this._vnode) {\n\t\t// Set render mode so that we can differentiate where the render request\n\t\t// is coming from. We need this because forceUpdate should never call\n\t\t// shouldComponentUpdate\n\t\tthis._force = true;\n\t\tif (callback) this._renderCallbacks.push(callback);\n\t\tenqueueRender(this);\n\t}\n};\n\n/**\n * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.\n * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).\n * @param {object} props Props (eg: JSX attributes) received from parent\n * element/component\n * @param {object} state The component's current state\n * @param {object} context Context object, as returned by the nearest\n * ancestor's `getChildContext()`\n * @returns {ComponentChildren | void}\n */\nBaseComponent.prototype.render = Fragment;\n\n/**\n * @param {VNode} vnode\n * @param {number | null} [childIndex]\n */\nexport function getDomSibling(vnode, childIndex) {\n\tif (childIndex == null) {\n\t\t// Use childIndex==null as a signal to resume the search from the vnode's sibling\n\t\treturn vnode._parent\n\t\t\t? getDomSibling(vnode._parent, vnode._index + 1)\n\t\t\t: null;\n\t}\n\n\tlet sibling;\n\tfor (; childIndex < vnode._children.length; childIndex++) {\n\t\tsibling = vnode._children[childIndex];\n\n\t\tif (sibling != null && sibling._dom != null) {\n\t\t\t// Since updateParentDomPointers keeps _dom pointer correct,\n\t\t\t// we can rely on _dom to tell us if this subtree contains a\n\t\t\t// rendered DOM node, and what the first rendered DOM node is\n\t\t\treturn sibling._dom;\n\t\t}\n\t}\n\n\t// If we get here, we have not found a DOM node in this vnode's children.\n\t// We must resume from this vnode's sibling (in it's parent _children array)\n\t// Only climb up and search the parent if we aren't searching through a DOM\n\t// VNode (meaning we reached the DOM parent of the original vnode that began\n\t// the search)\n\treturn typeof vnode.type == 'function' ? getDomSibling(vnode) : null;\n}\n\n/**\n * Trigger in-place re-rendering of a component.\n * @param {Component} component The component to rerender\n */\nfunction renderComponent(component) {\n\tlet oldVNode = component._vnode,\n\t\toldDom = oldVNode._dom,\n\t\tparentDom = component._parentDom,\n\t\tcommitQueue = [],\n\t\trefQueue = [];\n\n\tif (parentDom) {\n\t\tconst newVNode = assign({}, oldVNode);\n\t\tnewVNode._original = oldVNode._original + 1;\n\t\tif (options.vnode) options.vnode(newVNode);\n\n\t\tdiff(\n\t\t\tparentDom,\n\t\t\tnewVNode,\n\t\t\toldVNode,\n\t\t\tcomponent._globalContext,\n\t\t\tparentDom.ownerSVGElement !== undefined,\n\t\t\toldVNode._flags & MODE_HYDRATE ? [oldDom] : null,\n\t\t\tcommitQueue,\n\t\t\toldDom == null ? getDomSibling(oldVNode) : oldDom,\n\t\t\t!!(oldVNode._flags & MODE_HYDRATE),\n\t\t\trefQueue\n\t\t);\n\n\t\tnewVNode._original = oldVNode._original;\n\t\tnewVNode._parent._children[newVNode._index] = newVNode;\n\t\tcommitRoot(commitQueue, newVNode, refQueue);\n\n\t\tif (newVNode._dom != oldDom) {\n\t\t\tupdateParentDomPointers(newVNode);\n\t\t}\n\t}\n}\n\n/**\n * @param {VNode} vnode\n */\nfunction updateParentDomPointers(vnode) {\n\tif ((vnode = vnode._parent) != null && vnode._component != null) {\n\t\tvnode._dom = vnode._component.base = null;\n\t\tfor (let i = 0; i < vnode._children.length; i++) {\n\t\t\tlet child = vnode._children[i];\n\t\t\tif (child != null && child._dom != null) {\n\t\t\t\tvnode._dom = vnode._component.base = child._dom;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\treturn updateParentDomPointers(vnode);\n\t}\n}\n\n/**\n * The render queue\n * @type {Array<Component>}\n */\nlet rerenderQueue = [];\n\n/*\n * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is\n * important that contributors to Preact can consistently reason about what calls to `setState`, etc.\n * do, and when their effects will be applied. See the links below for some further reading on designing\n * asynchronous APIs.\n * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)\n * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)\n */\n\nlet prevDebounce;\n\nconst defer =\n\ttypeof Promise == 'function'\n\t\t? Promise.prototype.then.bind(Promise.resolve())\n\t\t: setTimeout;\n\n/**\n * Enqueue a rerender of a component\n * @param {Component} c The component to rerender\n */\nexport function enqueueRender(c) {\n\tif (\n\t\t(!c._dirty &&\n\t\t\t(c._dirty = true) &&\n\t\t\trerenderQueue.push(c) &&\n\t\t\t!process._rerenderCount++) ||\n\t\tprevDebounce !== options.debounceRendering\n\t) {\n\t\tprevDebounce = options.debounceRendering;\n\t\t(prevDebounce || defer)(process);\n\t}\n}\n\n/**\n * @param {Component} a\n * @param {Component} b\n */\nconst depthSort = (a, b) => a._vnode._depth - b._vnode._depth;\n\n/** Flush the render queue by rerendering all queued components */\nfunction process() {\n\tlet c;\n\trerenderQueue.sort(depthSort);\n\t// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary\n\t// process() calls from getting scheduled while `queue` is still being consumed.\n\twhile ((c = rerenderQueue.shift())) {\n\t\tif (c._dirty) {\n\t\t\tlet renderQueueLength = rerenderQueue.length;\n\t\t\trenderComponent(c);\n\t\t\tif (rerenderQueue.length > renderQueueLength) {\n\t\t\t\t// When i.e. rerendering a provider additional new items can be injected, we want to\n\t\t\t\t// keep the order from top to bottom with those new items so we can handle them in a\n\t\t\t\t// single pass\n\t\t\t\trerenderQueue.sort(depthSort);\n\t\t\t}\n\t\t}\n\t}\n\tprocess._rerenderCount = 0;\n}\n\nprocess._rerenderCount = 0;\n","import { diff, unmount, applyRef } from './index';\nimport { createVNode, Fragment } from '../create-element';\nimport { EMPTY_OBJ, EMPTY_ARR, INSERT_VNODE, MATCHED } from '../constants';\nimport { isArray } from '../util';\nimport { getDomSibling } from '../component';\n\n/**\n * Diff the children of a virtual node\n * @param {PreactElement} parentDom The DOM element whose children are being\n * diffed\n * @param {ComponentChildren[]} renderResult\n * @param {VNode} newParentVNode The new virtual node whose children should be\n * diff'ed against oldParentVNode\n * @param {VNode} oldParentVNode The old virtual node whose children should be\n * diff'ed against newParentVNode\n * @param {object} globalContext The current context object - modified by\n * getChildContext\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {Array<PreactElement>} excessDomChildren\n * @param {Array<Component>} commitQueue List of components which have callbacks\n * to invoke in commitRoot\n * @param {PreactElement} oldDom The current attached DOM element any new dom\n * elements should be placed around. Likely `null` on first render (except when\n * hydrating). Can be a sibling DOM element when diffing Fragments that have\n * siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {any[]} refQueue an array of elements needed to invoke refs\n */\nexport function diffChildren(\n\tparentDom,\n\trenderResult,\n\tnewParentVNode,\n\toldParentVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating,\n\trefQueue\n) {\n\tlet i,\n\t\t/** @type {VNode} */\n\t\toldVNode,\n\t\t/** @type {VNode} */\n\t\tchildVNode,\n\t\t/** @type {PreactElement} */\n\t\tnewDom,\n\t\t/** @type {PreactElement} */\n\t\tfirstChildDom;\n\n\t// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR\n\t// as EMPTY_OBJ._children should be `undefined`.\n\t/** @type {VNode[]} */\n\tlet oldChildren = (oldParentVNode && oldParentVNode._children) || EMPTY_ARR;\n\n\tlet newChildrenLength = renderResult.length;\n\n\tnewParentVNode._nextDom = oldDom;\n\tconstructNewChildrenArray(newParentVNode, renderResult, oldChildren);\n\toldDom = newParentVNode._nextDom;\n\n\tfor (i = 0; i < newChildrenLength; i++) {\n\t\tchildVNode = newParentVNode._children[i];\n\t\tif (\n\t\t\tchildVNode == null ||\n\t\t\ttypeof childVNode == 'boolean' ||\n\t\t\ttypeof childVNode == 'function'\n\t\t) {\n\t\t\tcontinue;\n\t\t}\n\n\t\t// At this point, constructNewChildrenArray has assigned _index to be the\n\t\t// matchingIndex for this VNode's oldVNode (or -1 if there is no oldVNode).\n\t\tif (childVNode._index === -1) {\n\t\t\toldVNode = EMPTY_OBJ;\n\t\t} else {\n\t\t\toldVNode = oldChildren[childVNode._index] || EMPTY_OBJ;\n\t\t}\n\n\t\t// Update childVNode._index to its final index\n\t\tchildVNode._index = i;\n\n\t\t// Morph the old element into the new one, but don't append it to the dom yet\n\t\tdiff(\n\t\t\tparentDom,\n\t\t\tchildVNode,\n\t\t\toldVNode,\n\t\t\tglobalContext,\n\t\t\tisSvg,\n\t\t\texcessDomChildren,\n\t\t\tcommitQueue,\n\t\t\toldDom,\n\t\t\tisHydrating,\n\t\t\trefQueue\n\t\t);\n\n\t\t// Adjust DOM nodes\n\t\tnewDom = childVNode._dom;\n\t\tif (childVNode.ref && oldVNode.ref != childVNode.ref) {\n\t\t\tif (oldVNode.ref) {\n\t\t\t\tapplyRef(oldVNode.ref, null, childVNode);\n\t\t\t}\n\t\t\trefQueue.push(\n\t\t\t\tchildVNode.ref,\n\t\t\t\tchildVNode._component || newDom,\n\t\t\t\tchildVNode\n\t\t\t);\n\t\t}\n\n\t\tif (firstChildDom == null && newDom != null) {\n\t\t\tfirstChildDom = newDom;\n\t\t}\n\n\t\tif (\n\t\t\tchildVNode._flags & INSERT_VNODE ||\n\t\t\toldVNode._children === childVNode._children\n\t\t) {\n\t\t\tif (!newDom && oldVNode._dom == oldDom) {\n\t\t\t\toldDom = getDomSibling(oldVNode);\n\t\t\t}\n\t\t\toldDom = insert(childVNode, oldDom, parentDom);\n\t\t} else if (\n\t\t\ttypeof childVNode.type == 'function' &&\n\t\t\tchildVNode._nextDom !== undefined\n\t\t) {\n\t\t\t// Since Fragments or components that return Fragment like VNodes can\n\t\t\t// contain multiple DOM nodes as the same level, continue the diff from\n\t\t\t// the sibling of last DOM child of this child VNode\n\t\t\toldDom = childVNode._nextDom;\n\t\t} else if (newDom) {\n\t\t\toldDom = newDom.nextSibling;\n\t\t}\n\n\t\t// Eagerly cleanup _nextDom. We don't need to persist the value because it\n\t\t// is only used by `diffChildren` to determine where to resume the diff\n\t\t// after diffing Components and Fragments. Once we store it the nextDOM\n\t\t// local var, we can clean up the property. Also prevents us hanging on to\n\t\t// DOM nodes that may have been unmounted.\n\t\tchildVNode._nextDom = undefined;\n\n\t\t// Unset diffing flags\n\t\tchildVNode._flags &= ~(INSERT_VNODE | MATCHED);\n\t}\n\n\t// TODO: With new child diffing algo, consider alt ways to diff Fragments.\n\t// Such as dropping oldDom and moving fragments in place\n\t//\n\t// Because the newParentVNode is Fragment-like, we need to set it's\n\t// _nextDom property to the nextSibling of its last child DOM node.\n\t//\n\t// `oldDom` contains the correct value here because if the last child\n\t// is a Fragment-like, then oldDom has already been set to that child's _nextDom.\n\t// If the last child is a DOM VNode, then oldDom will be set to that DOM\n\t// node's nextSibling.\n\tnewParentVNode._nextDom = oldDom;\n\tnewParentVNode._dom = firstChildDom;\n}\n\n/**\n * @param {VNode} newParentVNode\n * @param {ComponentChildren[]} renderResult\n * @param {VNode[]} oldChildren\n */\nfunction constructNewChildrenArray(newParentVNode, renderResult, oldChildren) {\n\t/** @type {number} */\n\tlet i;\n\t/** @type {VNode} */\n\tlet childVNode;\n\t/** @type {VNode} */\n\tlet oldVNode;\n\n\tconst newChildrenLength = renderResult.length;\n\tlet oldChildrenLength = oldChildren.length,\n\t\tremainingOldChildren = oldChildrenLength;\n\n\tlet skew = 0;\n\n\tnewParentVNode._children = [];\n\tfor (i = 0; i < newChildrenLength; i++) {\n\t\t// @ts-expect-error We are reusing the childVNode variable to hold both the\n\t\t// pre and post normalized childVNode\n\t\tchildVNode = renderResult[i];\n\n\t\tif (\n\t\t\tchildVNode == null ||\n\t\t\ttypeof childVNode == 'boolean' ||\n\t\t\ttypeof childVNode == 'function'\n\t\t) {\n\t\t\tchildVNode = newParentVNode._children[i] = null;\n\t\t}\n\t\t// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,\n\t\t// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have\n\t\t// it's own DOM & etc. pointers\n\t\telse if (\n\t\t\ttypeof childVNode == 'string' ||\n\t\t\ttypeof childVNode == 'number' ||\n\t\t\t// eslint-disable-next-line valid-typeof\n\t\t\ttypeof childVNode == 'bigint' ||\n\t\t\tchildVNode.constructor == String\n\t\t) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tnull,\n\t\t\t\tchildVNode,\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tnull\n\t\t\t);\n\t\t} else if (isArray(childVNode)) {\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tFragment,\n\t\t\t\t{ children: childVNode },\n\t\t\t\tnull,\n\t\t\t\tnull,\n\t\t\t\tnull\n\t\t\t);\n\t\t} else if (childVNode.constructor === undefined && childVNode._depth > 0) {\n\t\t\t// VNode is already in use, clone it. This can happen in the following\n\t\t\t// scenario:\n\t\t\t//   const reuse = <div />\n\t\t\t//   <div>{reuse}<span />{reuse}</div>\n\t\t\tchildVNode = newParentVNode._children[i] = createVNode(\n\t\t\t\tchildVNode.type,\n\t\t\t\tchildVNode.props,\n\t\t\t\tchildVNode.key,\n\t\t\t\tchildVNode.ref ? childVNode.ref : null,\n\t\t\t\tchildVNode._original\n\t\t\t);\n\t\t} else {\n\t\t\tchildVNode = newParentVNode._children[i] = childVNode;\n\t\t}\n\n\t\tconst skewedIndex = i + skew;\n\n\t\t// Handle unmounting null placeholders, i.e. VNode => null in unkeyed children\n\t\tif (childVNode == null) {\n\t\t\toldVNode = oldChildren[skewedIndex];\n\t\t\tif (\n\t\t\t\toldVNode &&\n\t\t\t\toldVNode.key == null &&\n\t\t\t\toldVNode._dom &&\n\t\t\t\t(oldVNode._flags & MATCHED) === 0\n\t\t\t) {\n\t\t\t\tif (oldVNode._dom == newParentVNode._nextDom) {\n\t\t\t\t\tnewParentVNode._nextDom = getDomSibling(oldVNode);\n\t\t\t\t}\n\n\t\t\t\tunmount(oldVNode, oldVNode, false);\n\n\t\t\t\t// Explicitly nullify this position in oldChildren instead of just\n\t\t\t\t// setting `_match=true` to prevent other routines (e.g.\n\t\t\t\t// `findMatchingIndex` or `getDomSibling`) from thinking VNodes or DOM\n\t\t\t\t// nodes in this position are still available to be used in diffing when\n\t\t\t\t// they have actually already been unmounted. For example, by only\n\t\t\t\t// setting `_match=true` here, the unmounting loop later would attempt\n\t\t\t\t// to unmount this VNode again seeing `_match==true`.  Further,\n\t\t\t\t// getDomSibling doesn't know about _match and so would incorrectly\n\t\t\t\t// assume DOM nodes in this subtree are mounted and usable.\n\t\t\t\toldChildren[skewedIndex] = null;\n\t\t\t\tremainingOldChildren--;\n\t\t\t}\n\t\t\tcontinue;\n\t\t}\n\n\t\tchildVNode._parent = newParentVNode;\n\t\tchildVNode._depth = newParentVNode._depth + 1;\n\n\t\tconst matchingIndex = findMatchingIndex(\n\t\t\tchildVNode,\n\t\t\toldChildren,\n\t\t\tskewedIndex,\n\t\t\tremainingOldChildren\n\t\t);\n\n\t\t// Temporarily store the matchingIndex on the _index property so we can pull\n\t\t// out the oldVNode in diffChildren. We'll override this to the VNode's\n\t\t// final index after using this property to get the oldVNode\n\t\tchildVNode._index = matchingIndex;\n\n\t\toldVNode = null;\n\t\tif (matchingIndex !== -1) {\n\t\t\toldVNode = oldChildren[matchingIndex];\n\t\t\tremainingOldChildren--;\n\t\t\tif (oldVNode) {\n\t\t\t\toldVNode._flags |= MATCHED;\n\t\t\t}\n\t\t}\n\n\t\t// Here, we define isMounting for the purposes of the skew diffing\n\t\t// algorithm. Nodes that are unsuspending are considered mounting and we detect\n\t\t// this by checking if oldVNode._original === null\n\t\tconst isMounting = oldVNode == null || oldVNode._original === null;\n\n\t\tif (isMounting) {\n\t\t\tif (matchingIndex == -1) {\n\t\t\t\tskew--;\n\t\t\t}\n\n\t\t\t// If we are mounting a DOM VNode, mark it for insertion\n\t\t\tif (typeof childVNode.type != 'function') {\n\t\t\t\tchildVNode._flags |= INSERT_VNODE;\n\t\t\t}\n\t\t} else if (matchingIndex !== skewedIndex) {\n\t\t\tif (matchingIndex === skewedIndex + 1) {\n\t\t\t\tskew++;\n\t\t\t} else if (matchingIndex > skewedIndex) {\n\t\t\t\tif (remainingOldChildren > newChildrenLength - skewedIndex) {\n\t\t\t\t\tskew += matchingIndex - skewedIndex;\n\t\t\t\t} else {\n\t\t\t\t\tskew--;\n\t\t\t\t}\n\t\t\t} else if (matchingIndex < skewedIndex) {\n\t\t\t\tif (matchingIndex == skewedIndex - 1) {\n\t\t\t\t\tskew = matchingIndex - skewedIndex;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tskew = 0;\n\t\t\t}\n\n\t\t\t// Move this VNode's DOM if the original index (matchingIndex) doesn't\n\t\t\t// match the new skew index (i + new skew)\n\t\t\tif (matchingIndex !== i + skew) {\n\t\t\t\tchildVNode._flags |= INSERT_VNODE;\n\t\t\t}\n\t\t}\n\t}\n\n\t// Remove remaining oldChildren if there are any. Loop forwards so that as we\n\t// unmount DOM from the beginning of the oldChildren, we can adjust oldDom to\n\t// point to the next child, which needs to be the first DOM node that won't be\n\t// unmounted.\n\tif (remainingOldChildren) {\n\t\tfor (i = 0; i < oldChildrenLength; i++) {\n\t\t\toldVNode = oldChildren[i];\n\t\t\tif (oldVNode != null && (oldVNode._flags & MATCHED) === 0) {\n\t\t\t\tif (oldVNode._dom == newParentVNode._nextDom) {\n\t\t\t\t\tnewParentVNode._nextDom = getDomSibling(oldVNode);\n\t\t\t\t}\n\n\t\t\t\tunmount(oldVNode, oldVNode);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * @param {VNode} parentVNode\n * @param {PreactElement} oldDom\n * @param {PreactElement} parentDom\n * @returns {PreactElement}\n */\nfunction insert(parentVNode, oldDom, parentDom) {\n\t// Note: VNodes in nested suspended trees may be missing _children.\n\n\tif (typeof parentVNode.type == 'function') {\n\t\tlet children = parentVNode._children;\n\t\tfor (let i = 0; children && i < children.length; i++) {\n\t\t\tif (children[i]) {\n\t\t\t\t// If we enter this code path on sCU bailout, where we copy\n\t\t\t\t// oldVNode._children to newVNode._children, we need to update the old\n\t\t\t\t// children's _parent pointer to point to the newVNode (parentVNode\n\t\t\t\t// here).\n\t\t\t\tchildren[i]._parent = parentVNode;\n\t\t\t\toldDom = insert(children[i], oldDom, parentDom);\n\t\t\t}\n\t\t}\n\n\t\treturn oldDom;\n\t} else if (parentVNode._dom != oldDom) {\n\t\tparentDom.insertBefore(parentVNode._dom, oldDom || null);\n\t\toldDom = parentVNode._dom;\n\t}\n\n\tdo {\n\t\toldDom = oldDom && oldDom.nextSibling;\n\t} while (oldDom != null && oldDom.nodeType === 8);\n\n\treturn oldDom;\n}\n\n/**\n * Flatten and loop through the children of a virtual node\n * @param {ComponentChildren} children The unflattened children of a virtual\n * node\n * @returns {VNode[]}\n */\nexport function toChildArray(children, out) {\n\tout = out || [];\n\tif (children == null || typeof children == 'boolean') {\n\t} else if (isArray(children)) {\n\t\tchildren.some(child => {\n\t\t\ttoChildArray(child, out);\n\t\t});\n\t} else {\n\t\tout.push(children);\n\t}\n\treturn out;\n}\n\n/**\n * @param {VNode} childVNode\n * @param {VNode[]} oldChildren\n * @param {number} skewedIndex\n * @param {number} remainingOldChildren\n * @returns {number}\n */\nfunction findMatchingIndex(\n\tchildVNode,\n\toldChildren,\n\tskewedIndex,\n\tremainingOldChildren\n) {\n\tconst key = childVNode.key;\n\tconst type = childVNode.type;\n\tlet x = skewedIndex - 1;\n\tlet y = skewedIndex + 1;\n\tlet oldVNode = oldChildren[skewedIndex];\n\n\t// We only need to perform a search if there are more children\n\t// (remainingOldChildren) to search. However, if the oldVNode we just looked\n\t// at skewedIndex was not already used in this diff, then there must be at\n\t// least 1 other (so greater than 1) remainingOldChildren to attempt to match\n\t// against. So the following condition checks that ensuring\n\t// remainingOldChildren > 1 if the oldVNode is not already used/matched. Else\n\t// if the oldVNode was null or matched, then there could needs to be at least\n\t// 1 (aka `remainingOldChildren > 0`) children to find and compare against.\n\tlet shouldSearch =\n\t\tremainingOldChildren >\n\t\t(oldVNode != null && (oldVNode._flags & MATCHED) === 0 ? 1 : 0);\n\n\tif (\n\t\toldVNode === null ||\n\t\t(oldVNode &&\n\t\t\tkey == oldVNode.key &&\n\t\t\ttype === oldVNode.type &&\n\t\t\t(oldVNode._flags & MATCHED) === 0)\n\t) {\n\t\treturn skewedIndex;\n\t} else if (shouldSearch) {\n\t\twhile (x >= 0 || y < oldChildren.length) {\n\t\t\tif (x >= 0) {\n\t\t\t\toldVNode = oldChildren[x];\n\t\t\t\tif (\n\t\t\t\t\toldVNode &&\n\t\t\t\t\t(oldVNode._flags & MATCHED) === 0 &&\n\t\t\t\t\tkey == oldVNode.key &&\n\t\t\t\t\ttype === oldVNode.type\n\t\t\t\t) {\n\t\t\t\t\treturn x;\n\t\t\t\t}\n\t\t\t\tx--;\n\t\t\t}\n\n\t\t\tif (y < oldChildren.length) {\n\t\t\t\toldVNode = oldChildren[y];\n\t\t\t\tif (\n\t\t\t\t\toldVNode &&\n\t\t\t\t\t(oldVNode._flags & MATCHED) === 0 &&\n\t\t\t\t\tkey == oldVNode.key &&\n\t\t\t\t\ttype === oldVNode.type\n\t\t\t\t) {\n\t\t\t\t\treturn y;\n\t\t\t\t}\n\t\t\t\ty++;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn -1;\n}\n","import { IS_NON_DIMENSIONAL } from '../constants';\nimport options from '../options';\n\nfunction setStyle(style, key, value) {\n\tif (key[0] === '-') {\n\t\tstyle.setProperty(key, value == null ? '' : value);\n\t} else if (value == null) {\n\t\tstyle[key] = '';\n\t} else if (typeof value != 'number' || IS_NON_DIMENSIONAL.test(key)) {\n\t\tstyle[key] = value;\n\t} else {\n\t\tstyle[key] = value + 'px';\n\t}\n}\n\n/**\n * Set a property value on a DOM node\n * @param {PreactElement} dom The DOM node to modify\n * @param {string} name The name of the property to set\n * @param {*} value The value to set the property to\n * @param {*} oldValue The old value the property had\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node or not\n */\nexport function setProperty(dom, name, value, oldValue, isSvg) {\n\tlet useCapture;\n\n\to: if (name === 'style') {\n\t\tif (typeof value == 'string') {\n\t\t\tdom.style.cssText = value;\n\t\t} else {\n\t\t\tif (typeof oldValue == 'string') {\n\t\t\t\tdom.style.cssText = oldValue = '';\n\t\t\t}\n\n\t\t\tif (oldValue) {\n\t\t\t\tfor (name in oldValue) {\n\t\t\t\t\tif (!(value && name in value)) {\n\t\t\t\t\t\tsetStyle(dom.style, name, '');\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif (value) {\n\t\t\t\tfor (name in value) {\n\t\t\t\t\tif (!oldValue || value[name] !== oldValue[name]) {\n\t\t\t\t\t\tsetStyle(dom.style, name, value[name]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\t// Benchmark for comparison: https://esbench.com/bench/574c954bdb965b9a00965ac6\n\telse if (name[0] === 'o' && name[1] === 'n') {\n\t\tuseCapture =\n\t\t\tname !== (name = name.replace(/(PointerCapture)$|Capture$/i, '$1'));\n\n\t\t// Infer correct casing for DOM built-in events:\n\t\tif (\n\t\t\tname.toLowerCase() in dom ||\n\t\t\tname === 'onFocusOut' ||\n\t\t\tname === 'onFocusIn'\n\t\t)\n\t\t\tname = name.toLowerCase().slice(2);\n\t\telse name = name.slice(2);\n\n\t\tif (!dom._listeners) dom._listeners = {};\n\t\tdom._listeners[name + useCapture] = value;\n\n\t\tif (value) {\n\t\t\tif (!oldValue) {\n\t\t\t\tvalue._attached = Date.now();\n\t\t\t\tconst handler = useCapture ? eventProxyCapture : eventProxy;\n\t\t\t\tdom.addEventListener(name, handler, useCapture);\n\t\t\t} else {\n\t\t\t\tvalue._attached = oldValue._attached;\n\t\t\t}\n\t\t} else {\n\t\t\tconst handler = useCapture ? eventProxyCapture : eventProxy;\n\t\t\tdom.removeEventListener(name, handler, useCapture);\n\t\t}\n\t} else {\n\t\tif (isSvg) {\n\t\t\t// Normalize incorrect prop usage for SVG:\n\t\t\t// - xlink:href / xlinkHref --> href (xlink:href was removed from SVG and isn't needed)\n\t\t\t// - className --> class\n\t\t\tname = name.replace(/xlink(H|:h)/, 'h').replace(/sName$/, 's');\n\t\t} else if (\n\t\t\tname !== 'width' &&\n\t\t\tname !== 'height' &&\n\t\t\tname !== 'href' &&\n\t\t\tname !== 'list' &&\n\t\t\tname !== 'form' &&\n\t\t\t// Default value in browsers is `-1` and an empty string is\n\t\t\t// cast to `0` instead\n\t\t\tname !== 'tabIndex' &&\n\t\t\tname !== 'download' &&\n\t\t\tname !== 'rowSpan' &&\n\t\t\tname !== 'colSpan' &&\n\t\t\tname !== 'role' &&\n\t\t\tname in dom\n\t\t) {\n\t\t\ttry {\n\t\t\t\tdom[name] = value == null ? '' : value;\n\t\t\t\t// labelled break is 1b smaller here than a return statement (sorry)\n\t\t\t\tbreak o;\n\t\t\t} catch (e) {}\n\t\t}\n\n\t\t// aria- and data- attributes have no boolean representation.\n\t\t// A `false` value is different from the attribute not being\n\t\t// present, so we can't remove it. For non-boolean aria\n\t\t// attributes we could treat false as a removal, but the\n\t\t// amount of exceptions would cost too many bytes. On top of\n\t\t// that other frameworks generally stringify `false`.\n\n\t\tif (typeof value == 'function') {\n\t\t\t// never serialize functions as attribute values\n\t\t} else if (value != null && (value !== false || name[4] === '-')) {\n\t\t\tdom.setAttribute(name, value);\n\t\t} else {\n\t\t\tdom.removeAttribute(name);\n\t\t}\n\t}\n}\n\n/**\n * Proxy an event to hooked event handlers\n * @param {PreactEvent} e The event object from the browser\n * @private\n */\nfunction eventProxy(e) {\n\tif (this._listeners) {\n\t\tconst eventHandler = this._listeners[e.type + false];\n\t\t/**\n\t\t * This trick is inspired by Vue https://github.com/vuejs/core/blob/main/packages/runtime-dom/src/modules/events.ts#L90-L101\n\t\t * when the dom performs an event it leaves micro-ticks in between bubbling up which means that an event can trigger on a newly\n\t\t * created DOM-node while the event bubbles up, this can cause quirky behavior as seen in https://github.com/preactjs/preact/issues/3927\n\t\t */\n\t\tif (!e._dispatched) {\n\t\t\t// When an event has no _dispatched we know this is the first event-target in the chain\n\t\t\t// so we set the initial dispatched time.\n\t\t\te._dispatched = Date.now();\n\t\t\t// When the _dispatched is smaller than the time when the targetted event handler was attached\n\t\t\t// we know we have bubbled up to an element that was added during patching the dom.\n\t\t} else if (e._dispatched <= eventHandler._attached) {\n\t\t\treturn;\n\t\t}\n\t\treturn eventHandler(options.event ? options.event(e) : e);\n\t}\n}\n\n/**\n * Proxy an event to hooked event handlers\n * @param {PreactEvent} e The event object from the browser\n * @private\n */\nfunction eventProxyCapture(e) {\n\tif (this._listeners) {\n\t\treturn this._listeners[e.type + true](options.event ? options.event(e) : e);\n\t}\n}\n","import {\n\tEMPTY_OBJ,\n\tMODE_HYDRATE,\n\tMODE_SUSPENDED,\n\tRESET_MODE\n} from '../constants';\nimport { BaseComponent, getDomSibling } from '../component';\nimport { Fragment } from '../create-element';\nimport { diffChildren } from './children';\nimport { setProperty } from './props';\nimport { assign, isArray, removeNode, slice } from '../util';\nimport options from '../options';\n\n/**\n * Diff two virtual nodes and apply proper changes to the DOM\n * @param {PreactElement} parentDom The parent of the DOM element\n * @param {VNode} newVNode The new virtual node\n * @param {VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object. Modified by\n * getChildContext\n * @param {boolean} isSvg Whether or not this element is an SVG node\n * @param {Array<PreactElement>} excessDomChildren\n * @param {Array<Component>} commitQueue List of components which have callbacks\n * to invoke in commitRoot\n * @param {PreactElement} oldDom The current attached DOM element any new dom\n * elements should be placed around. Likely `null` on first render (except when\n * hydrating). Can be a sibling DOM element when diffing Fragments that have\n * siblings. In most cases, it starts out as `oldChildren[0]._dom`.\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {any[]} refQueue an array of elements needed to invoke refs\n */\nexport function diff(\n\tparentDom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\toldDom,\n\tisHydrating,\n\trefQueue\n) {\n\t/** @type {any} */\n\tlet tmp,\n\t\tnewType = newVNode.type;\n\n\t// When passing through createElement it assigns the object\n\t// constructor as undefined. This to prevent JSON-injection.\n\tif (newVNode.constructor !== undefined) return null;\n\n\t// If the previous diff bailed out, resume creating/hydrating.\n\tif (oldVNode._flags & MODE_SUSPENDED) {\n\t\tisHydrating = !!(oldVNode._flags & MODE_HYDRATE);\n\t\toldDom = newVNode._dom = oldVNode._dom;\n\t\texcessDomChildren = [oldDom];\n\t}\n\n\tif ((tmp = options._diff)) tmp(newVNode);\n\n\touter: if (typeof newType == 'function') {\n\t\ttry {\n\t\t\tlet c, isNew, oldProps, oldState, snapshot, clearProcessingException;\n\t\t\tlet newProps = newVNode.props;\n\n\t\t\t// Necessary for createContext api. Setting this property will pass\n\t\t\t// the context value as `this.context` just for this component.\n\t\t\ttmp = newType.contextType;\n\t\t\tlet provider = tmp && globalContext[tmp._id];\n\t\t\tlet componentContext = tmp\n\t\t\t\t? provider\n\t\t\t\t\t? provider.props.value\n\t\t\t\t\t: tmp._defaultValue\n\t\t\t\t: globalContext;\n\n\t\t\t// Get component and set it to `c`\n\t\t\tif (oldVNode._component) {\n\t\t\t\tc = newVNode._component = oldVNode._component;\n\t\t\t\tclearProcessingException = c._processingException = c._pendingError;\n\t\t\t} else {\n\t\t\t\t// Instantiate the new component\n\t\t\t\tif ('prototype' in newType && newType.prototype.render) {\n\t\t\t\t\t// @ts-expect-error The check above verifies that newType is suppose to be constructed\n\t\t\t\t\tnewVNode._component = c = new newType(newProps, componentContext); // eslint-disable-line new-cap\n\t\t\t\t} else {\n\t\t\t\t\t// @ts-expect-error Trust me, Component implements the interface we want\n\t\t\t\t\tnewVNode._component = c = new BaseComponent(\n\t\t\t\t\t\tnewProps,\n\t\t\t\t\t\tcomponentContext\n\t\t\t\t\t);\n\t\t\t\t\tc.constructor = newType;\n\t\t\t\t\tc.render = doRender;\n\t\t\t\t}\n\t\t\t\tif (provider) provider.sub(c);\n\n\t\t\t\tc.props = newProps;\n\t\t\t\tif (!c.state) c.state = {};\n\t\t\t\tc.context = componentContext;\n\t\t\t\tc._globalContext = globalContext;\n\t\t\t\tisNew = c._dirty = true;\n\t\t\t\tc._renderCallbacks = [];\n\t\t\t\tc._stateCallbacks = [];\n\t\t\t}\n\n\t\t\t// Invoke getDerivedStateFromProps\n\t\t\tif (c._nextState == null) {\n\t\t\t\tc._nextState = c.state;\n\t\t\t}\n\n\t\t\tif (newType.getDerivedStateFromProps != null) {\n\t\t\t\tif (c._nextState == c.state) {\n\t\t\t\t\tc._nextState = assign({}, c._nextState);\n\t\t\t\t}\n\n\t\t\t\tassign(\n\t\t\t\t\tc._nextState,\n\t\t\t\t\tnewType.getDerivedStateFromProps(newProps, c._nextState)\n\t\t\t\t);\n\t\t\t}\n\n\t\t\toldProps = c.props;\n\t\t\toldState = c.state;\n\t\t\tc._vnode = newVNode;\n\n\t\t\t// Invoke pre-render lifecycle methods\n\t\t\tif (isNew) {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tc.componentWillMount != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillMount();\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidMount != null) {\n\t\t\t\t\tc._renderCallbacks.push(c.componentDidMount);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (\n\t\t\t\t\tnewType.getDerivedStateFromProps == null &&\n\t\t\t\t\tnewProps !== oldProps &&\n\t\t\t\t\tc.componentWillReceiveProps != null\n\t\t\t\t) {\n\t\t\t\t\tc.componentWillReceiveProps(newProps, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (\n\t\t\t\t\t!c._force &&\n\t\t\t\t\t((c.shouldComponentUpdate != null &&\n\t\t\t\t\t\tc.shouldComponentUpdate(\n\t\t\t\t\t\t\tnewProps,\n\t\t\t\t\t\t\tc._nextState,\n\t\t\t\t\t\t\tcomponentContext\n\t\t\t\t\t\t) === false) ||\n\t\t\t\t\t\tnewVNode._original === oldVNode._original)\n\t\t\t\t) {\n\t\t\t\t\t// More info about this here: https://gist.github.com/JoviDeCroock/bec5f2ce93544d2e6070ef8e0036e4e8\n\t\t\t\t\tif (newVNode._original !== oldVNode._original) {\n\t\t\t\t\t\t// When we are dealing with a bail because of sCU we have to update\n\t\t\t\t\t\t// the props, state and dirty-state.\n\t\t\t\t\t\t// when we are dealing with strict-equality we don't as the child could still\n\t\t\t\t\t\t// be dirtied see #3883\n\t\t\t\t\t\tc.props = newProps;\n\t\t\t\t\t\tc.state = c._nextState;\n\t\t\t\t\t\tc._dirty = false;\n\t\t\t\t\t}\n\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t\tnewVNode._children.forEach(vnode => {\n\t\t\t\t\t\tif (vnode) vnode._parent = newVNode;\n\t\t\t\t\t});\n\n\t\t\t\t\tfor (let i = 0; i < c._stateCallbacks.length; i++) {\n\t\t\t\t\t\tc._renderCallbacks.push(c._stateCallbacks[i]);\n\t\t\t\t\t}\n\t\t\t\t\tc._stateCallbacks = [];\n\n\t\t\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\t\t\tcommitQueue.push(c);\n\t\t\t\t\t}\n\n\t\t\t\t\tbreak outer;\n\t\t\t\t}\n\n\t\t\t\tif (c.componentWillUpdate != null) {\n\t\t\t\t\tc.componentWillUpdate(newProps, c._nextState, componentContext);\n\t\t\t\t}\n\n\t\t\t\tif (c.componentDidUpdate != null) {\n\t\t\t\t\tc._renderCallbacks.push(() => {\n\t\t\t\t\t\tc.componentDidUpdate(oldProps, oldState, snapshot);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tc.context = componentContext;\n\t\t\tc.props = newProps;\n\t\t\tc._parentDom = parentDom;\n\t\t\tc._force = false;\n\n\t\t\tlet renderHook = options._render,\n\t\t\t\tcount = 0;\n\t\t\tif ('prototype' in newType && newType.prototype.render) {\n\t\t\t\tc.state = c._nextState;\n\t\t\t\tc._dirty = false;\n\n\t\t\t\tif (renderHook) renderHook(newVNode);\n\n\t\t\t\ttmp = c.render(c.props, c.state, c.context);\n\n\t\t\t\tfor (let i = 0; i < c._stateCallbacks.length; i++) {\n\t\t\t\t\tc._renderCallbacks.push(c._stateCallbacks[i]);\n\t\t\t\t}\n\t\t\t\tc._stateCallbacks = [];\n\t\t\t} else {\n\t\t\t\tdo {\n\t\t\t\t\tc._dirty = false;\n\t\t\t\t\tif (renderHook) renderHook(newVNode);\n\n\t\t\t\t\ttmp = c.render(c.props, c.state, c.context);\n\n\t\t\t\t\t// Handle setState called in render, see #2553\n\t\t\t\t\tc.state = c._nextState;\n\t\t\t\t} while (c._dirty && ++count < 25);\n\t\t\t}\n\n\t\t\t// Handle setState called in render, see #2553\n\t\t\tc.state = c._nextState;\n\n\t\t\tif (c.getChildContext != null) {\n\t\t\t\tglobalContext = assign(assign({}, globalContext), c.getChildContext());\n\t\t\t}\n\n\t\t\tif (!isNew && c.getSnapshotBeforeUpdate != null) {\n\t\t\t\tsnapshot = c.getSnapshotBeforeUpdate(oldProps, oldState);\n\t\t\t}\n\n\t\t\tlet isTopLevelFragment =\n\t\t\t\ttmp != null && tmp.type === Fragment && tmp.key == null;\n\t\t\tlet renderResult = isTopLevelFragment ? tmp.props.children : tmp;\n\n\t\t\tdiffChildren(\n\t\t\t\tparentDom,\n\t\t\t\tisArray(renderResult) ? renderResult : [renderResult],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg,\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\toldDom,\n\t\t\t\tisHydrating,\n\t\t\t\trefQueue\n\t\t\t);\n\n\t\t\tc.base = newVNode._dom;\n\n\t\t\t// We successfully rendered this VNode, unset any stored hydration/bailout state:\n\t\t\tnewVNode._flags &= RESET_MODE;\n\n\t\t\tif (c._renderCallbacks.length) {\n\t\t\t\tcommitQueue.push(c);\n\t\t\t}\n\n\t\t\tif (clearProcessingException) {\n\t\t\t\tc._pendingError = c._processingException = null;\n\t\t\t}\n\t\t} catch (e) {\n\t\t\tnewVNode._original = null;\n\t\t\t// if hydrating or creating initial tree, bailout preserves DOM:\n\t\t\tif (isHydrating || excessDomChildren != null) {\n\t\t\t\tnewVNode._dom = oldDom;\n\t\t\t\tnewVNode._flags |= isHydrating\n\t\t\t\t\t? MODE_HYDRATE | MODE_SUSPENDED\n\t\t\t\t\t: MODE_HYDRATE;\n\t\t\t\texcessDomChildren[excessDomChildren.indexOf(oldDom)] = null;\n\t\t\t\t// ^ could possibly be simplified to:\n\t\t\t\t// excessDomChildren.length = 0;\n\t\t\t} else {\n\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t}\n\t\t\toptions._catchError(e, newVNode, oldVNode);\n\t\t}\n\t} else if (\n\t\texcessDomChildren == null &&\n\t\tnewVNode._original === oldVNode._original\n\t) {\n\t\tnewVNode._children = oldVNode._children;\n\t\tnewVNode._dom = oldVNode._dom;\n\t} else {\n\t\tnewVNode._dom = diffElementNodes(\n\t\t\toldVNode._dom,\n\t\t\tnewVNode,\n\t\t\toldVNode,\n\t\t\tglobalContext,\n\t\t\tisSvg,\n\t\t\texcessDomChildren,\n\t\t\tcommitQueue,\n\t\t\tisHydrating,\n\t\t\trefQueue\n\t\t);\n\t}\n\n\tif ((tmp = options.diffed)) tmp(newVNode);\n}\n\n/**\n * @param {Array<Component>} commitQueue List of components\n * which have callbacks to invoke in commitRoot\n * @param {VNode} root\n */\nexport function commitRoot(commitQueue, root, refQueue) {\n\troot._nextDom = undefined;\n\n\tfor (let i = 0; i < refQueue.length; i++) {\n\t\tapplyRef(refQueue[i], refQueue[++i], refQueue[++i]);\n\t}\n\n\tif (options._commit) options._commit(root, commitQueue);\n\n\tcommitQueue.some(c => {\n\t\ttry {\n\t\t\t// @ts-expect-error Reuse the commitQueue variable here so the type changes\n\t\t\tcommitQueue = c._renderCallbacks;\n\t\t\tc._renderCallbacks = [];\n\t\t\tcommitQueue.some(cb => {\n\t\t\t\t// @ts-expect-error See above comment on commitQueue\n\t\t\t\tcb.call(c);\n\t\t\t});\n\t\t} catch (e) {\n\t\t\toptions._catchError(e, c._vnode);\n\t\t}\n\t});\n}\n\n/**\n * Diff two virtual nodes representing DOM element\n * @param {PreactElement} dom The DOM element representing the virtual nodes\n * being diffed\n * @param {VNode} newVNode The new virtual node\n * @param {VNode} oldVNode The old virtual node\n * @param {object} globalContext The current context object\n * @param {boolean} isSvg Whether or not this DOM node is an SVG node\n * @param {Array<PreactElement>} excessDomChildren\n * @param {Array<Component>} commitQueue List of components which have callbacks\n * to invoke in commitRoot\n * @param {boolean} isHydrating Whether or not we are in hydration\n * @param {any[]} refQueue an array of elements needed to invoke refs\n * @returns {PreactElement}\n */\nfunction diffElementNodes(\n\tdom,\n\tnewVNode,\n\toldVNode,\n\tglobalContext,\n\tisSvg,\n\texcessDomChildren,\n\tcommitQueue,\n\tisHydrating,\n\trefQueue\n) {\n\tlet oldProps = oldVNode.props;\n\tlet newProps = newVNode.props;\n\tlet nodeType = /** @type {string} */ (newVNode.type);\n\t/** @type {any} */\n\tlet i;\n\t/** @type {{ __html?: string }} */\n\tlet newHtml;\n\t/** @type {{ __html?: string }} */\n\tlet oldHtml;\n\t/** @type {ComponentChildren} */\n\tlet newChildren;\n\tlet value;\n\tlet inputValue;\n\tlet checked;\n\n\t// Tracks entering and exiting SVG namespace when descending through the tree.\n\tif (nodeType === 'svg') isSvg = true;\n\n\tif (excessDomChildren != null) {\n\t\tfor (i = 0; i < excessDomChildren.length; i++) {\n\t\t\tvalue = excessDomChildren[i];\n\n\t\t\t// if newVNode matches an element in excessDomChildren or the `dom`\n\t\t\t// argument matches an element in excessDomChildren, remove it from\n\t\t\t// excessDomChildren so it isn't later removed in diffChildren\n\t\t\tif (\n\t\t\t\tvalue &&\n\t\t\t\t'setAttribute' in value === !!nodeType &&\n\t\t\t\t(nodeType ? value.localName === nodeType : value.nodeType === 3)\n\t\t\t) {\n\t\t\t\tdom = value;\n\t\t\t\texcessDomChildren[i] = null;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\tif (dom == null) {\n\t\tif (nodeType === null) {\n\t\t\treturn document.createTextNode(newProps);\n\t\t}\n\n\t\tif (isSvg) {\n\t\t\tdom = document.createElementNS('http://www.w3.org/2000/svg', nodeType);\n\t\t} else {\n\t\t\tdom = document.createElement(nodeType, newProps.is && newProps);\n\t\t}\n\n\t\t// we created a new parent, so none of the previously attached children can be reused:\n\t\texcessDomChildren = null;\n\t\t// we are creating a new node, so we can assume this is a new subtree (in\n\t\t// case we are hydrating), this deopts the hydrate\n\t\tisHydrating = false;\n\t}\n\n\tif (nodeType === null) {\n\t\t// During hydration, we still have to split merged text from SSR'd HTML.\n\t\tif (oldProps !== newProps && (!isHydrating || dom.data !== newProps)) {\n\t\t\tdom.data = newProps;\n\t\t}\n\t} else {\n\t\t// If excessDomChildren was not null, repopulate it with the current element's children:\n\t\texcessDomChildren = excessDomChildren && slice.call(dom.childNodes);\n\n\t\toldProps = oldVNode.props || EMPTY_OBJ;\n\n\t\t// If we are in a situation where we are not hydrating but are using\n\t\t// existing DOM (e.g. replaceNode) we should read the existing DOM\n\t\t// attributes to diff them\n\t\tif (!isHydrating && excessDomChildren != null) {\n\t\t\toldProps = {};\n\t\t\tfor (i = 0; i < dom.attributes.length; i++) {\n\t\t\t\tvalue = dom.attributes[i];\n\t\t\t\toldProps[value.name] = value.value;\n\t\t\t}\n\t\t}\n\n\t\tfor (i in oldProps) {\n\t\t\tvalue = oldProps[i];\n\t\t\tif (i == 'children') {\n\t\t\t} else if (i == 'dangerouslySetInnerHTML') {\n\t\t\t\toldHtml = value;\n\t\t\t} else if (i !== 'key' && !(i in newProps)) {\n\t\t\t\tsetProperty(dom, i, null, value, isSvg);\n\t\t\t}\n\t\t}\n\n\t\t// During hydration, props are not diffed at all (including dangerouslySetInnerHTML)\n\t\t// @TODO we should warn in debug mode when props don't match here.\n\t\tfor (i in newProps) {\n\t\t\tvalue = newProps[i];\n\t\t\tif (i == 'children') {\n\t\t\t\tnewChildren = value;\n\t\t\t} else if (i == 'dangerouslySetInnerHTML') {\n\t\t\t\tnewHtml = value;\n\t\t\t} else if (i == 'value') {\n\t\t\t\tinputValue = value;\n\t\t\t} else if (i == 'checked') {\n\t\t\t\tchecked = value;\n\t\t\t} else if (\n\t\t\t\ti !== 'key' &&\n\t\t\t\t(!isHydrating || typeof value == 'function') &&\n\t\t\t\toldProps[i] !== value\n\t\t\t) {\n\t\t\t\tsetProperty(dom, i, value, oldProps[i], isSvg);\n\t\t\t}\n\t\t}\n\n\t\t// If the new vnode didn't have dangerouslySetInnerHTML, diff its children\n\t\tif (newHtml) {\n\t\t\t// Avoid re-applying the same '__html' if it did not changed between re-render\n\t\t\tif (\n\t\t\t\t!isHydrating &&\n\t\t\t\t(!oldHtml ||\n\t\t\t\t\t(newHtml.__html !== oldHtml.__html &&\n\t\t\t\t\t\tnewHtml.__html !== dom.innerHTML))\n\t\t\t) {\n\t\t\t\tdom.innerHTML = newHtml.__html;\n\t\t\t}\n\n\t\t\tnewVNode._children = [];\n\t\t} else {\n\t\t\tif (oldHtml) dom.innerHTML = '';\n\n\t\t\tdiffChildren(\n\t\t\t\tdom,\n\t\t\t\tisArray(newChildren) ? newChildren : [newChildren],\n\t\t\t\tnewVNode,\n\t\t\t\toldVNode,\n\t\t\t\tglobalContext,\n\t\t\t\tisSvg && nodeType !== 'foreignObject',\n\t\t\t\texcessDomChildren,\n\t\t\t\tcommitQueue,\n\t\t\t\texcessDomChildren\n\t\t\t\t\t? excessDomChildren[0]\n\t\t\t\t\t: oldVNode._children && getDomSibling(oldVNode, 0),\n\t\t\t\tisHydrating,\n\t\t\t\trefQueue\n\t\t\t);\n\n\t\t\t// Remove children that are not part of any vnode.\n\t\t\tif (excessDomChildren != null) {\n\t\t\t\tfor (i = excessDomChildren.length; i--; ) {\n\t\t\t\t\tif (excessDomChildren[i] != null) removeNode(excessDomChildren[i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// As above, don't diff props during hydration\n\t\tif (!isHydrating) {\n\t\t\ti = 'value';\n\t\t\tif (\n\t\t\t\tinputValue !== undefined &&\n\t\t\t\t// #2756 For the <progress>-element the initial value is 0,\n\t\t\t\t// despite the attribute not being present. When the attribute\n\t\t\t\t// is missing the progress bar is treated as indeterminate.\n\t\t\t\t// To fix that we'll always update it when it is 0 for progress elements\n\t\t\t\t(inputValue !== dom[i] ||\n\t\t\t\t\t(nodeType === 'progress' && !inputValue) ||\n\t\t\t\t\t// This is only for IE 11 to fix <select> value not being updated.\n\t\t\t\t\t// To avoid a stale select value we need to set the option.value\n\t\t\t\t\t// again, which triggers IE11 to re-evaluate the select value\n\t\t\t\t\t(nodeType === 'option' && inputValue !== oldProps[i]))\n\t\t\t) {\n\t\t\t\tsetProperty(dom, i, inputValue, oldProps[i], false);\n\t\t\t}\n\n\t\t\ti = 'checked';\n\t\t\tif (checked !== undefined && checked !== dom[i]) {\n\t\t\t\tsetProperty(dom, i, checked, oldProps[i], false);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn dom;\n}\n\n/**\n * Invoke or update a ref, depending on whether it is a function or object ref.\n * @param {Ref<any>} ref\n * @param {any} value\n * @param {VNode} vnode\n */\nexport function applyRef(ref, value, vnode) {\n\ttry {\n\t\tif (typeof ref == 'function') ref(value);\n\t\telse ref.current = value;\n\t} catch (e) {\n\t\toptions._catchError(e, vnode);\n\t}\n}\n\n/**\n * Unmount a virtual node from the tree and apply DOM changes\n * @param {VNode} vnode The virtual node to unmount\n * @param {VNode} parentVNode The parent of the VNode that initiated the unmount\n * @param {boolean} [skipRemove] Flag that indicates that a parent node of the\n * current element is already detached from the DOM.\n */\nexport function unmount(vnode, parentVNode, skipRemove) {\n\tlet r;\n\tif (options.unmount) options.unmount(vnode);\n\n\tif ((r = vnode.ref)) {\n\t\tif (!r.current || r.current === vnode._dom) {\n\t\t\tapplyRef(r, null, parentVNode);\n\t\t}\n\t}\n\n\tif ((r = vnode._component) != null) {\n\t\tif (r.componentWillUnmount) {\n\t\t\ttry {\n\t\t\t\tr.componentWillUnmount();\n\t\t\t} catch (e) {\n\t\t\t\toptions._catchError(e, parentVNode);\n\t\t\t}\n\t\t}\n\n\t\tr.base = r._parentDom = null;\n\t\tvnode._component = undefined;\n\t}\n\n\tif ((r = vnode._children)) {\n\t\tfor (let i = 0; i < r.length; i++) {\n\t\t\tif (r[i]) {\n\t\t\t\tunmount(\n\t\t\t\t\tr[i],\n\t\t\t\t\tparentVNode,\n\t\t\t\t\tskipRemove || typeof vnode.type !== 'function'\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\tif (!skipRemove && vnode._dom != null) {\n\t\tremoveNode(vnode._dom);\n\t}\n\n\t// Must be set to `undefined` to properly clean up `_nextDom`\n\t// for which `null` is a valid value. See comment in `create-element.js`\n\tvnode._parent = vnode._dom = vnode._nextDom = undefined;\n}\n\n/** The `.render()` method for a PFC backing instance. */\nfunction doRender(props, state, context) {\n\treturn this.constructor(props, context);\n}\n","/**\n * Find the closest error boundary to a thrown error and call it\n * @param {object} error The thrown value\n * @param {VNode} vnode The vnode that threw the error that was caught (except\n * for unmounting when this parameter is the highest parent that was being\n * unmounted)\n * @param {VNode} [oldVNode]\n * @param {ErrorInfo} [errorInfo]\n */\nexport function _catchError(error, vnode, oldVNode, errorInfo) {\n\t/** @type {Component} */\n\tlet component,\n\t\t/** @type {ComponentType} */\n\t\tctor,\n\t\t/** @type {boolean} */\n\t\thandled;\n\n\tfor (; (vnode = vnode._parent); ) {\n\t\tif ((component = vnode._component) && !component._processingException) {\n\t\t\ttry {\n\t\t\t\tctor = component.constructor;\n\n\t\t\t\tif (ctor && ctor.getDerivedStateFromError != null) {\n\t\t\t\t\tcomponent.setState(ctor.getDerivedStateFromError(error));\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\tif (component.componentDidCatch != null) {\n\t\t\t\t\tcomponent.componentDidCatch(error, errorInfo || {});\n\t\t\t\t\thandled = component._dirty;\n\t\t\t\t}\n\n\t\t\t\t// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.\n\t\t\t\tif (handled) {\n\t\t\t\t\treturn (component._pendingError = component);\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\terror = e;\n\t\t\t}\n\t\t}\n\t}\n\n\tthrow error;\n}\n","\n      import API from \"!../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n      import domAPI from \"!../../node_modules/style-loader/dist/runtime/styleDomAPI.js\";\n      import insertFn from \"!../../node_modules/style-loader/dist/runtime/insertBySelector.js\";\n      import setAttributes from \"!../../node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js\";\n      import insertStyleElement from \"!../../node_modules/style-loader/dist/runtime/insertStyleElement.js\";\n      import styleTagTransformFn from \"!../../node_modules/style-loader/dist/runtime/styleTagTransform.js\";\n      import content, * as namedExport from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./index.scss\";\n      \n      \n\nvar options = {};\n\noptions.styleTagTransform = styleTagTransformFn;\noptions.setAttributes = setAttributes;\n\n      options.insert = insertFn.bind(null, \"head\");\n    \noptions.domAPI = domAPI;\noptions.insertStyleElement = insertStyleElement;\n\nvar update = API(content, options);\n\n\n\nexport * from \"!!../../node_modules/css-loader/dist/cjs.js!../../node_modules/sass-loader/dist/cjs.js!./index.scss\";\n       export default content && content.locals ? content.locals : undefined;\n","import { options as _options } from 'preact';\n\n/** @type {number} */\nlet currentIndex;\n\n/** @type {import('./internal').Component} */\nlet currentComponent;\n\n/** @type {import('./internal').Component} */\nlet previousComponent;\n\n/** @type {number} */\nlet currentHook = 0;\n\n/** @type {Array<import('./internal').Component>} */\nlet afterPaintEffects = [];\n\nlet EMPTY = [];\n\n// Cast to use internal Options type\nconst options = /** @type {import('./internal').Options} */ (_options);\n\nlet oldBeforeDiff = options._diff;\nlet oldBeforeRender = options._render;\nlet oldAfterDiff = options.diffed;\nlet oldCommit = options._commit;\nlet oldBeforeUnmount = options.unmount;\nlet oldRoot = options._root;\n\nconst RAF_TIMEOUT = 100;\nlet prevRaf;\n\n/** @type {(vnode: import('./internal').VNode) => void} */\noptions._diff = vnode => {\n\tcurrentComponent = null;\n\tif (oldBeforeDiff) oldBeforeDiff(vnode);\n};\n\noptions._root = (vnode, parentDom) => {\n\tif (vnode && parentDom._children && parentDom._children._mask) {\n\t\tvnode._mask = parentDom._children._mask;\n\t}\n\n\tif (oldRoot) oldRoot(vnode, parentDom);\n};\n\n/** @type {(vnode: import('./internal').VNode) => void} */\noptions._render = vnode => {\n\tif (oldBeforeRender) oldBeforeRender(vnode);\n\n\tcurrentComponent = vnode._component;\n\tcurrentIndex = 0;\n\n\tconst hooks = currentComponent.__hooks;\n\tif (hooks) {\n\t\tif (previousComponent === currentComponent) {\n\t\t\thooks._pendingEffects = [];\n\t\t\tcurrentComponent._renderCallbacks = [];\n\t\t\thooks._list.forEach(hookItem => {\n\t\t\t\tif (hookItem._nextValue) {\n\t\t\t\t\thookItem._value = hookItem._nextValue;\n\t\t\t\t}\n\t\t\t\thookItem._pendingValue = EMPTY;\n\t\t\t\thookItem._nextValue = hookItem._pendingArgs = undefined;\n\t\t\t});\n\t\t} else {\n\t\t\thooks._pendingEffects.forEach(invokeCleanup);\n\t\t\thooks._pendingEffects.forEach(invokeEffect);\n\t\t\thooks._pendingEffects = [];\n\t\t\tcurrentIndex = 0;\n\t\t}\n\t}\n\tpreviousComponent = currentComponent;\n};\n\n/** @type {(vnode: import('./internal').VNode) => void} */\noptions.diffed = vnode => {\n\tif (oldAfterDiff) oldAfterDiff(vnode);\n\n\tconst c = vnode._component;\n\tif (c && c.__hooks) {\n\t\tif (c.__hooks._pendingEffects.length) afterPaint(afterPaintEffects.push(c));\n\t\tc.__hooks._list.forEach(hookItem => {\n\t\t\tif (hookItem._pendingArgs) {\n\t\t\t\thookItem._args = hookItem._pendingArgs;\n\t\t\t}\n\t\t\tif (hookItem._pendingValue !== EMPTY) {\n\t\t\t\thookItem._value = hookItem._pendingValue;\n\t\t\t}\n\t\t\thookItem._pendingArgs = undefined;\n\t\t\thookItem._pendingValue = EMPTY;\n\t\t});\n\t}\n\tpreviousComponent = currentComponent = null;\n};\n\n// TODO: Improve typing of commitQueue parameter\n/** @type {(vnode: import('./internal').VNode, commitQueue: any) => void} */\noptions._commit = (vnode, commitQueue) => {\n\tcommitQueue.some(component => {\n\t\ttry {\n\t\t\tcomponent._renderCallbacks.forEach(invokeCleanup);\n\t\t\tcomponent._renderCallbacks = component._renderCallbacks.filter(cb =>\n\t\t\t\tcb._value ? invokeEffect(cb) : true\n\t\t\t);\n\t\t} catch (e) {\n\t\t\tcommitQueue.some(c => {\n\t\t\t\tif (c._renderCallbacks) c._renderCallbacks = [];\n\t\t\t});\n\t\t\tcommitQueue = [];\n\t\t\toptions._catchError(e, component._vnode);\n\t\t}\n\t});\n\n\tif (oldCommit) oldCommit(vnode, commitQueue);\n};\n\n/** @type {(vnode: import('./internal').VNode) => void} */\noptions.unmount = vnode => {\n\tif (oldBeforeUnmount) oldBeforeUnmount(vnode);\n\n\tconst c = vnode._component;\n\tif (c && c.__hooks) {\n\t\tlet hasErrored;\n\t\tc.__hooks._list.forEach(s => {\n\t\t\ttry {\n\t\t\t\tinvokeCleanup(s);\n\t\t\t} catch (e) {\n\t\t\t\thasErrored = e;\n\t\t\t}\n\t\t});\n\t\tc.__hooks = undefined;\n\t\tif (hasErrored) options._catchError(hasErrored, c._vnode);\n\t}\n};\n\n/**\n * Get a hook's state from the currentComponent\n * @param {number} index The index of the hook to get\n * @param {number} type The index of the hook to get\n * @returns {any}\n */\nfunction getHookState(index, type) {\n\tif (options._hook) {\n\t\toptions._hook(currentComponent, index, currentHook || type);\n\t}\n\tcurrentHook = 0;\n\n\t// Largely inspired by:\n\t// * https://github.com/michael-klein/funcy.js/blob/f6be73468e6ec46b0ff5aa3cc4c9baf72a29025a/src/hooks/core_hooks.mjs\n\t// * https://github.com/michael-klein/funcy.js/blob/650beaa58c43c33a74820a3c98b3c7079cf2e333/src/renderer.mjs\n\t// Other implementations to look at:\n\t// * https://codesandbox.io/s/mnox05qp8\n\tconst hooks =\n\t\tcurrentComponent.__hooks ||\n\t\t(currentComponent.__hooks = {\n\t\t\t_list: [],\n\t\t\t_pendingEffects: []\n\t\t});\n\n\tif (index >= hooks._list.length) {\n\t\thooks._list.push({ _pendingValue: EMPTY });\n\t}\n\n\treturn hooks._list[index];\n}\n\n/**\n * @template {unknown} S\n * @param {import('./index').Dispatch<import('./index').StateUpdater<S>>} [initialState]\n * @returns {[S, (state: S) => void]}\n */\nexport function useState(initialState) {\n\tcurrentHook = 1;\n\treturn useReducer(invokeOrReturn, initialState);\n}\n\n/**\n * @template {unknown} S\n * @template {unknown} A\n * @param {import('./index').Reducer<S, A>} reducer\n * @param {import('./index').Dispatch<import('./index').StateUpdater<S>>} initialState\n * @param {(initialState: any) => void} [init]\n * @returns {[ S, (state: S) => void ]}\n */\nexport function useReducer(reducer, initialState, init) {\n\t/** @type {import('./internal').ReducerHookState} */\n\tconst hookState = getHookState(currentIndex++, 2);\n\thookState._reducer = reducer;\n\tif (!hookState._component) {\n\t\thookState._value = [\n\t\t\t!init ? invokeOrReturn(undefined, initialState) : init(initialState),\n\n\t\t\taction => {\n\t\t\t\tconst currentValue = hookState._nextValue\n\t\t\t\t\t? hookState._nextValue[0]\n\t\t\t\t\t: hookState._value[0];\n\t\t\t\tconst nextValue = hookState._reducer(currentValue, action);\n\n\t\t\t\tif (currentValue !== nextValue) {\n\t\t\t\t\thookState._nextValue = [nextValue, hookState._value[1]];\n\t\t\t\t\thookState._component.setState({});\n\t\t\t\t}\n\t\t\t}\n\t\t];\n\n\t\thookState._component = currentComponent;\n\n\t\tif (!currentComponent._hasScuFromHooks) {\n\t\t\tcurrentComponent._hasScuFromHooks = true;\n\t\t\tlet prevScu = currentComponent.shouldComponentUpdate;\n\t\t\tconst prevCWU = currentComponent.componentWillUpdate;\n\n\t\t\t// If we're dealing with a forced update `shouldComponentUpdate` will\n\t\t\t// not be called. But we use that to update the hook values, so we\n\t\t\t// need to call it.\n\t\t\tcurrentComponent.componentWillUpdate = function (p, s, c) {\n\t\t\t\tif (this._force) {\n\t\t\t\t\tlet tmp = prevScu;\n\t\t\t\t\t// Clear to avoid other sCU hooks from being called\n\t\t\t\t\tprevScu = undefined;\n\t\t\t\t\tupdateHookState(p, s, c);\n\t\t\t\t\tprevScu = tmp;\n\t\t\t\t}\n\n\t\t\t\tif (prevCWU) prevCWU.call(this, p, s, c);\n\t\t\t};\n\n\t\t\t// This SCU has the purpose of bailing out after repeated updates\n\t\t\t// to stateful hooks.\n\t\t\t// we store the next value in _nextValue[0] and keep doing that for all\n\t\t\t// state setters, if we have next states and\n\t\t\t// all next states within a component end up being equal to their original state\n\t\t\t// we are safe to bail out for this specific component.\n\t\t\t/**\n\t\t\t *\n\t\t\t * @type {import('./internal').Component[\"shouldComponentUpdate\"]}\n\t\t\t */\n\t\t\t// @ts-ignore - We don't use TS to downtranspile\n\t\t\t// eslint-disable-next-line no-inner-declarations\n\t\t\tfunction updateHookState(p, s, c) {\n\t\t\t\tif (!hookState._component.__hooks) return true;\n\n\t\t\t\t/** @type {(x: import('./internal').HookState) => x is import('./internal').ReducerHookState} */\n\t\t\t\tconst isStateHook = x => !!x._component;\n\t\t\t\tconst stateHooks =\n\t\t\t\t\thookState._component.__hooks._list.filter(isStateHook);\n\n\t\t\t\tconst allHooksEmpty = stateHooks.every(x => !x._nextValue);\n\t\t\t\t// When we have no updated hooks in the component we invoke the previous SCU or\n\t\t\t\t// traverse the VDOM tree further.\n\t\t\t\tif (allHooksEmpty) {\n\t\t\t\t\treturn prevScu ? prevScu.call(this, p, s, c) : true;\n\t\t\t\t}\n\n\t\t\t\t// We check whether we have components with a nextValue set that\n\t\t\t\t// have values that aren't equal to one another this pushes\n\t\t\t\t// us to update further down the tree\n\t\t\t\tlet shouldUpdate = false;\n\t\t\t\tstateHooks.forEach(hookItem => {\n\t\t\t\t\tif (hookItem._nextValue) {\n\t\t\t\t\t\tconst currentValue = hookItem._value[0];\n\t\t\t\t\t\thookItem._value = hookItem._nextValue;\n\t\t\t\t\t\thookItem._nextValue = undefined;\n\t\t\t\t\t\tif (currentValue !== hookItem._value[0]) shouldUpdate = true;\n\t\t\t\t\t}\n\t\t\t\t});\n\n\t\t\t\treturn shouldUpdate || hookState._component.props !== p\n\t\t\t\t\t? prevScu\n\t\t\t\t\t\t? prevScu.call(this, p, s, c)\n\t\t\t\t\t\t: true\n\t\t\t\t\t: false;\n\t\t\t}\n\n\t\t\tcurrentComponent.shouldComponentUpdate = updateHookState;\n\t\t}\n\t}\n\n\treturn hookState._nextValue || hookState._value;\n}\n\n/**\n * @param {import('./internal').Effect} callback\n * @param {unknown[]} args\n * @returns {void}\n */\nexport function useEffect(callback, args) {\n\t/** @type {import('./internal').EffectHookState} */\n\tconst state = getHookState(currentIndex++, 3);\n\tif (!options._skipEffects && argsChanged(state._args, args)) {\n\t\tstate._value = callback;\n\t\tstate._pendingArgs = args;\n\n\t\tcurrentComponent.__hooks._pendingEffects.push(state);\n\t}\n}\n\n/**\n * @param {import('./internal').Effect} callback\n * @param {unknown[]} args\n * @returns {void}\n */\nexport function useLayoutEffect(callback, args) {\n\t/** @type {import('./internal').EffectHookState} */\n\tconst state = getHookState(currentIndex++, 4);\n\tif (!options._skipEffects && argsChanged(state._args, args)) {\n\t\tstate._value = callback;\n\t\tstate._pendingArgs = args;\n\n\t\tcurrentComponent._renderCallbacks.push(state);\n\t}\n}\n\n/** @type {(initialValue: unknown) => unknown} */\nexport function useRef(initialValue) {\n\tcurrentHook = 5;\n\treturn useMemo(() => ({ current: initialValue }), []);\n}\n\n/**\n * @param {object} ref\n * @param {() => object} createHandle\n * @param {unknown[]} args\n * @returns {void}\n */\nexport function useImperativeHandle(ref, createHandle, args) {\n\tcurrentHook = 6;\n\tuseLayoutEffect(\n\t\t() => {\n\t\t\tif (typeof ref == 'function') {\n\t\t\t\tref(createHandle());\n\t\t\t\treturn () => ref(null);\n\t\t\t} else if (ref) {\n\t\t\t\tref.current = createHandle();\n\t\t\t\treturn () => (ref.current = null);\n\t\t\t}\n\t\t},\n\t\targs == null ? args : args.concat(ref)\n\t);\n}\n\n/**\n * @template {unknown} T\n * @param {() => T} factory\n * @param {unknown[]} args\n * @returns {T}\n */\nexport function useMemo(factory, args) {\n\t/** @type {import('./internal').MemoHookState<T>} */\n\tconst state = getHookState(currentIndex++, 7);\n\tif (argsChanged(state._args, args)) {\n\t\tstate._pendingValue = factory();\n\t\tstate._pendingArgs = args;\n\t\tstate._factory = factory;\n\t\treturn state._pendingValue;\n\t}\n\n\treturn state._value;\n}\n\n/**\n * @param {() => void} callback\n * @param {unknown[]} args\n * @returns {() => void}\n */\nexport function useCallback(callback, args) {\n\tcurrentHook = 8;\n\treturn useMemo(() => callback, args);\n}\n\n/**\n * @param {import('./internal').PreactContext} context\n */\nexport function useContext(context) {\n\tconst provider = currentComponent.context[context._id];\n\t// We could skip this call here, but than we'd not call\n\t// `options._hook`. We need to do that in order to make\n\t// the devtools aware of this hook.\n\t/** @type {import('./internal').ContextHookState} */\n\tconst state = getHookState(currentIndex++, 9);\n\t// The devtools needs access to the context object to\n\t// be able to pull of the default value when no provider\n\t// is present in the tree.\n\tstate._context = context;\n\tif (!provider) return context._defaultValue;\n\t// This is probably not safe to convert to \"!\"\n\tif (state._value == null) {\n\t\tstate._value = true;\n\t\tprovider.sub(currentComponent);\n\t}\n\treturn provider.props.value;\n}\n\n/**\n * Display a custom label for a custom hook for the devtools panel\n * @type {<T>(value: T, cb?: (value: T) => string | number) => void}\n */\nexport function useDebugValue(value, formatter) {\n\tif (options.useDebugValue) {\n\t\toptions.useDebugValue(\n\t\t\tformatter ? formatter(value) : /** @type {any}*/ (value)\n\t\t);\n\t}\n}\n\n/**\n * @param {(error: unknown, errorInfo: import('preact').ErrorInfo) => void} cb\n * @returns {[unknown, () => void]}\n */\nexport function useErrorBoundary(cb) {\n\t/** @type {import('./internal').ErrorBoundaryHookState} */\n\tconst state = getHookState(currentIndex++, 10);\n\tconst errState = useState();\n\tstate._value = cb;\n\tif (!currentComponent.componentDidCatch) {\n\t\tcurrentComponent.componentDidCatch = (err, errorInfo) => {\n\t\t\tif (state._value) state._value(err, errorInfo);\n\t\t\terrState[1](err);\n\t\t};\n\t}\n\treturn [\n\t\terrState[0],\n\t\t() => {\n\t\t\terrState[1](undefined);\n\t\t}\n\t];\n}\n\n/** @type {() => string} */\nexport function useId() {\n\t/** @type {import('./internal').IdHookState} */\n\tconst state = getHookState(currentIndex++, 11);\n\tif (!state._value) {\n\t\t// Grab either the root node or the nearest async boundary node.\n\t\t/** @type {import('./internal.d').VNode} */\n\t\tlet root = currentComponent._vnode;\n\t\twhile (root !== null && !root._mask && root._parent !== null) {\n\t\t\troot = root._parent;\n\t\t}\n\n\t\tlet mask = root._mask || (root._mask = [0, 0]);\n\t\tstate._value = 'P' + mask[0] + '-' + mask[1]++;\n\t}\n\n\treturn state._value;\n}\n\n/**\n * After paint effects consumer.\n */\nfunction flushAfterPaintEffects() {\n\tlet component;\n\twhile ((component = afterPaintEffects.shift())) {\n\t\tif (!component._parentDom || !component.__hooks) continue;\n\t\ttry {\n\t\t\tcomponent.__hooks._pendingEffects.forEach(invokeCleanup);\n\t\t\tcomponent.__hooks._pendingEffects.forEach(invokeEffect);\n\t\t\tcomponent.__hooks._pendingEffects = [];\n\t\t} catch (e) {\n\t\t\tcomponent.__hooks._pendingEffects = [];\n\t\t\toptions._catchError(e, component._vnode);\n\t\t}\n\t}\n}\n\nlet HAS_RAF = typeof requestAnimationFrame == 'function';\n\n/**\n * Schedule a callback to be invoked after the browser has a chance to paint a new frame.\n * Do this by combining requestAnimationFrame (rAF) + setTimeout to invoke a callback after\n * the next browser frame.\n *\n * Also, schedule a timeout in parallel to the the rAF to ensure the callback is invoked\n * even if RAF doesn't fire (for example if the browser tab is not visible)\n *\n * @param {() => void} callback\n */\nfunction afterNextFrame(callback) {\n\tconst done = () => {\n\t\tclearTimeout(timeout);\n\t\tif (HAS_RAF) cancelAnimationFrame(raf);\n\t\tsetTimeout(callback);\n\t};\n\tconst timeout = setTimeout(done, RAF_TIMEOUT);\n\n\tlet raf;\n\tif (HAS_RAF) {\n\t\traf = requestAnimationFrame(done);\n\t}\n}\n\n// Note: if someone used options.debounceRendering = requestAnimationFrame,\n// then effects will ALWAYS run on the NEXT frame instead of the current one, incurring a ~16ms delay.\n// Perhaps this is not such a big deal.\n/**\n * Schedule afterPaintEffects flush after the browser paints\n * @param {number} newQueueLength\n * @returns {void}\n */\nfunction afterPaint(newQueueLength) {\n\tif (newQueueLength === 1 || prevRaf !== options.requestAnimationFrame) {\n\t\tprevRaf = options.requestAnimationFrame;\n\t\t(prevRaf || afterNextFrame)(flushAfterPaintEffects);\n\t}\n}\n\n/**\n * @param {import('./internal').HookState} hook\n * @returns {void}\n */\nfunction invokeCleanup(hook) {\n\t// A hook cleanup can introduce a call to render which creates a new root, this will call options.vnode\n\t// and move the currentComponent away.\n\tconst comp = currentComponent;\n\tlet cleanup = hook._cleanup;\n\tif (typeof cleanup == 'function') {\n\t\thook._cleanup = undefined;\n\t\tcleanup();\n\t}\n\n\tcurrentComponent = comp;\n}\n\n/**\n * Invoke a Hook's effect\n * @param {import('./internal').EffectHookState} hook\n * @returns {void}\n */\nfunction invokeEffect(hook) {\n\t// A hook call can introduce a call to render which creates a new root, this will call options.vnode\n\t// and move the currentComponent away.\n\tconst comp = currentComponent;\n\thook._cleanup = hook._value();\n\tcurrentComponent = comp;\n}\n\n/**\n * @param {unknown[]} oldArgs\n * @param {unknown[]} newArgs\n * @returns {boolean}\n */\nfunction argsChanged(oldArgs, newArgs) {\n\treturn (\n\t\t!oldArgs ||\n\t\toldArgs.length !== newArgs.length ||\n\t\tnewArgs.some((arg, index) => arg !== oldArgs[index])\n\t);\n}\n\n/**\n * @template Arg\n * @param {Arg} arg\n * @param {(arg: Arg) => any} f\n * @returns {any}\n */\nfunction invokeOrReturn(arg, f) {\n\treturn typeof f == 'function' ? f(arg) : f;\n}\n","import { Component } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Component class with a predefined `shouldComponentUpdate` implementation\n */\nexport function PureComponent(p, c) {\n\tthis.props = p;\n\tthis.context = c;\n}\nPureComponent.prototype = new Component();\n// Some third-party libraries check if this property is present\nPureComponent.prototype.isPureReactComponent = true;\nPureComponent.prototype.shouldComponentUpdate = function (props, state) {\n\treturn shallowDiffers(this.props, props) || shallowDiffers(this.state, state);\n};\n","import { options } from 'preact';\nimport { assign } from './util';\n\nlet oldDiffHook = options._diff;\noptions._diff = vnode => {\n\tif (vnode.type && vnode.type._forwarded && vnode.ref) {\n\t\tvnode.props.ref = vnode.ref;\n\t\tvnode.ref = null;\n\t}\n\tif (oldDiffHook) oldDiffHook(vnode);\n};\n\nexport const REACT_FORWARD_SYMBOL =\n\t(typeof Symbol != 'undefined' &&\n\t\tSymbol.for &&\n\t\tSymbol.for('react.forward_ref')) ||\n\t0xf47;\n\n/**\n * Pass ref down to a child. This is mainly used in libraries with HOCs that\n * wrap components. Using `forwardRef` there is an easy way to get a reference\n * of the wrapped component instead of one of the wrapper itself.\n * @param {import('./index').ForwardFn} fn\n * @returns {import('./internal').FunctionComponent}\n */\nexport function forwardRef(fn) {\n\tfunction Forwarded(props) {\n\t\tlet clone = assign({}, props);\n\t\tdelete clone.ref;\n\t\treturn fn(clone, props.ref || null);\n\t}\n\n\t// mobx-react checks for this being present\n\tForwarded.$$typeof = REACT_FORWARD_SYMBOL;\n\t// mobx-react heavily relies on implementation details.\n\t// It expects an object here with a `render` property,\n\t// and prototype.render will fail. Without this\n\t// mobx-react throws.\n\tForwarded.render = Forwarded;\n\n\tForwarded.prototype.isReactComponent = Forwarded._forwarded = true;\n\tForwarded.displayName = 'ForwardRef(' + (fn.displayName || fn.name) + ')';\n\treturn Forwarded;\n}\n","import { toChildArray } from 'preact';\n\nconst mapFn = (children, fn) => {\n\tif (children == null) return null;\n\treturn toChildArray(toChildArray(children).map(fn));\n};\n\n// This API is completely unnecessary for Preact, so it's basically passthrough.\nexport const Children = {\n\tmap: mapFn,\n\tforEach: mapFn,\n\tcount(children) {\n\t\treturn children ? toChildArray(children).length : 0;\n\t},\n\tonly(children) {\n\t\tconst normalized = toChildArray(children);\n\t\tif (normalized.length !== 1) throw 'Children.only';\n\t\treturn normalized[0];\n\t},\n\ttoArray: toChildArray\n};\n","import { Component, createElement, options, Fragment } from 'preact';\nimport { MODE_HYDRATE } from '../../src/constants';\nimport { assign } from './util';\n\nconst oldCatchError = options._catchError;\noptions._catchError = function (error, newVNode, oldVNode, errorInfo) {\n\tif (error.then) {\n\t\t/** @type {import('./internal').Component} */\n\t\tlet component;\n\t\tlet vnode = newVNode;\n\n\t\tfor (; (vnode = vnode._parent); ) {\n\t\t\tif ((component = vnode._component) && component._childDidSuspend) {\n\t\t\t\tif (newVNode._dom == null) {\n\t\t\t\t\tnewVNode._dom = oldVNode._dom;\n\t\t\t\t\tnewVNode._children = oldVNode._children;\n\t\t\t\t}\n\t\t\t\t// Don't call oldCatchError if we found a Suspense\n\t\t\t\treturn component._childDidSuspend(error, newVNode);\n\t\t\t}\n\t\t}\n\t}\n\toldCatchError(error, newVNode, oldVNode, errorInfo);\n};\n\nconst oldUnmount = options.unmount;\noptions.unmount = function (vnode) {\n\t/** @type {import('./internal').Component} */\n\tconst component = vnode._component;\n\tif (component && component._onResolve) {\n\t\tcomponent._onResolve();\n\t}\n\n\t// if the component is still hydrating\n\t// most likely it is because the component is suspended\n\t// we set the vnode.type as `null` so that it is not a typeof function\n\t// so the unmount will remove the vnode._dom\n\tif (component && vnode._flags & MODE_HYDRATE) {\n\t\tvnode.type = null;\n\t}\n\n\tif (oldUnmount) oldUnmount(vnode);\n};\n\nfunction detachedClone(vnode, detachedParent, parentDom) {\n\tif (vnode) {\n\t\tif (vnode._component && vnode._component.__hooks) {\n\t\t\tvnode._component.__hooks._list.forEach(effect => {\n\t\t\t\tif (typeof effect._cleanup == 'function') effect._cleanup();\n\t\t\t});\n\n\t\t\tvnode._component.__hooks = null;\n\t\t}\n\n\t\tvnode = assign({}, vnode);\n\t\tif (vnode._component != null) {\n\t\t\tif (vnode._component._parentDom === parentDom) {\n\t\t\t\tvnode._component._parentDom = detachedParent;\n\t\t\t}\n\t\t\tvnode._component = null;\n\t\t}\n\n\t\tvnode._children =\n\t\t\tvnode._children &&\n\t\t\tvnode._children.map(child =>\n\t\t\t\tdetachedClone(child, detachedParent, parentDom)\n\t\t\t);\n\t}\n\n\treturn vnode;\n}\n\nfunction removeOriginal(vnode, detachedParent, originalParent) {\n\tif (vnode && originalParent) {\n\t\tvnode._original = null;\n\t\tvnode._children =\n\t\t\tvnode._children &&\n\t\t\tvnode._children.map(child =>\n\t\t\t\tremoveOriginal(child, detachedParent, originalParent)\n\t\t\t);\n\n\t\tif (vnode._component) {\n\t\t\tif (vnode._component._parentDom === detachedParent) {\n\t\t\t\tif (vnode._dom) {\n\t\t\t\t\toriginalParent.appendChild(vnode._dom);\n\t\t\t\t}\n\t\t\t\tvnode._component._force = true;\n\t\t\t\tvnode._component._parentDom = originalParent;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn vnode;\n}\n\n// having custom inheritance instead of a class here saves a lot of bytes\nexport function Suspense() {\n\t// we do not call super here to golf some bytes...\n\tthis._pendingSuspensionCount = 0;\n\tthis._suspenders = null;\n\tthis._detachOnNextRender = null;\n}\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspense.prototype = new Component();\n\n/**\n * @this {import('./internal').SuspenseComponent}\n * @param {Promise} promise The thrown promise\n * @param {import('./internal').VNode<any, any>} suspendingVNode The suspending component\n */\nSuspense.prototype._childDidSuspend = function (promise, suspendingVNode) {\n\tconst suspendingComponent = suspendingVNode._component;\n\n\t/** @type {import('./internal').SuspenseComponent} */\n\tconst c = this;\n\n\tif (c._suspenders == null) {\n\t\tc._suspenders = [];\n\t}\n\tc._suspenders.push(suspendingComponent);\n\n\tconst resolve = suspended(c._vnode);\n\n\tlet resolved = false;\n\tconst onResolved = () => {\n\t\tif (resolved) return;\n\n\t\tresolved = true;\n\t\tsuspendingComponent._onResolve = null;\n\n\t\tif (resolve) {\n\t\t\tresolve(onSuspensionComplete);\n\t\t} else {\n\t\t\tonSuspensionComplete();\n\t\t}\n\t};\n\n\tsuspendingComponent._onResolve = onResolved;\n\n\tconst onSuspensionComplete = () => {\n\t\tif (!--c._pendingSuspensionCount) {\n\t\t\t// If the suspension was during hydration we don't need to restore the\n\t\t\t// suspended children into the _children array\n\t\t\tif (c.state._suspended) {\n\t\t\t\tconst suspendedVNode = c.state._suspended;\n\t\t\t\tc._vnode._children[0] = removeOriginal(\n\t\t\t\t\tsuspendedVNode,\n\t\t\t\t\tsuspendedVNode._component._parentDom,\n\t\t\t\t\tsuspendedVNode._component._originalParentDom\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tc.setState({ _suspended: (c._detachOnNextRender = null) });\n\n\t\t\tlet suspended;\n\t\t\twhile ((suspended = c._suspenders.pop())) {\n\t\t\t\tsuspended.forceUpdate();\n\t\t\t}\n\t\t}\n\t};\n\n\t/**\n\t * We do not set `suspended: true` during hydration because we want the actual markup\n\t * to remain on screen and hydrate it when the suspense actually gets resolved.\n\t * While in non-hydration cases the usual fallback -> component flow would occour.\n\t */\n\tif (\n\t\t!c._pendingSuspensionCount++ &&\n\t\t!(suspendingVNode._flags & MODE_HYDRATE)\n\t) {\n\t\tc.setState({ _suspended: (c._detachOnNextRender = c._vnode._children[0]) });\n\t}\n\tpromise.then(onResolved, onResolved);\n};\n\nSuspense.prototype.componentWillUnmount = function () {\n\tthis._suspenders = [];\n};\n\n/**\n * @this {import('./internal').SuspenseComponent}\n * @param {import('./internal').SuspenseComponent[\"props\"]} props\n * @param {import('./internal').SuspenseState} state\n */\nSuspense.prototype.render = function (props, state) {\n\tif (this._detachOnNextRender) {\n\t\t// When the Suspense's _vnode was created by a call to createVNode\n\t\t// (i.e. due to a setState further up in the tree)\n\t\t// it's _children prop is null, in this case we \"forget\" about the parked vnodes to detach\n\t\tif (this._vnode._children) {\n\t\t\tconst detachedParent = document.createElement('div');\n\t\t\tconst detachedComponent = this._vnode._children[0]._component;\n\t\t\tthis._vnode._children[0] = detachedClone(\n\t\t\t\tthis._detachOnNextRender,\n\t\t\t\tdetachedParent,\n\t\t\t\t(detachedComponent._originalParentDom = detachedComponent._parentDom)\n\t\t\t);\n\t\t}\n\n\t\tthis._detachOnNextRender = null;\n\t}\n\n\t// Wrap fallback tree in a VNode that prevents itself from being marked as aborting mid-hydration:\n\t/** @type {import('./internal').VNode} */\n\tconst fallback =\n\t\tstate._suspended && createElement(Fragment, null, props.fallback);\n\tif (fallback) fallback._flags &= ~MODE_HYDRATE;\n\n\treturn [\n\t\tcreateElement(Fragment, null, state._suspended ? null : props.children),\n\t\tfallback\n\t];\n};\n\n/**\n * Checks and calls the parent component's _suspended method, passing in the\n * suspended vnode. This is a way for a parent (e.g. SuspenseList) to get notified\n * that one of its children/descendants suspended.\n *\n * The parent MAY return a callback. The callback will get called when the\n * suspension resolves, notifying the parent of the fact.\n * Moreover, the callback gets function `unsuspend` as a parameter. The resolved\n * child descendant will not actually get unsuspended until `unsuspend` gets called.\n * This is a way for the parent to delay unsuspending.\n *\n * If the parent does not return a callback then the resolved vnode\n * gets unsuspended immediately when it resolves.\n *\n * @param {import('./internal').VNode} vnode\n * @returns {((unsuspend: () => void) => void)?}\n */\nexport function suspended(vnode) {\n\t/** @type {import('./internal').Component} */\n\tlet component = vnode._parent._component;\n\treturn component && component._suspended && component._suspended(vnode);\n}\n\nexport function lazy(loader) {\n\tlet prom;\n\tlet component;\n\tlet error;\n\n\tfunction Lazy(props) {\n\t\tif (!prom) {\n\t\t\tprom = loader();\n\t\t\tprom.then(\n\t\t\t\texports => {\n\t\t\t\t\tcomponent = exports.default || exports;\n\t\t\t\t},\n\t\t\t\te => {\n\t\t\t\t\terror = e;\n\t\t\t\t}\n\t\t\t);\n\t\t}\n\n\t\tif (error) {\n\t\t\tthrow error;\n\t\t}\n\n\t\tif (!component) {\n\t\t\tthrow prom;\n\t\t}\n\n\t\treturn createElement(component, props);\n\t}\n\n\tLazy.displayName = 'Lazy';\n\tLazy._forwarded = true;\n\treturn Lazy;\n}\n","import { Component, toChildArray } from 'preact';\nimport { suspended } from './suspense.js';\n\n// Indexes to linked list nodes (nodes are stored as arrays to save bytes).\nconst SUSPENDED_COUNT = 0;\nconst RESOLVED_COUNT = 1;\nconst NEXT_NODE = 2;\n\n// Having custom inheritance instead of a class here saves a lot of bytes.\nexport function SuspenseList() {\n\tthis._next = null;\n\tthis._map = null;\n}\n\n// Mark one of child's earlier suspensions as resolved.\n// Some pending callbacks may become callable due to this\n// (e.g. the last suspended descendant gets resolved when\n// revealOrder === 'together'). Process those callbacks as well.\nconst resolve = (list, child, node) => {\n\tif (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {\n\t\t// The number a child (or any of its descendants) has been suspended\n\t\t// matches the number of times it's been resolved. Therefore we\n\t\t// mark the child as completely resolved by deleting it from ._map.\n\t\t// This is used to figure out when *all* children have been completely\n\t\t// resolved when revealOrder is 'together'.\n\t\tlist._map.delete(child);\n\t}\n\n\t// If revealOrder is falsy then we can do an early exit, as the\n\t// callbacks won't get queued in the node anyway.\n\t// If revealOrder is 'together' then also do an early exit\n\t// if all suspended descendants have not yet been resolved.\n\tif (\n\t\t!list.props.revealOrder ||\n\t\t(list.props.revealOrder[0] === 't' && list._map.size)\n\t) {\n\t\treturn;\n\t}\n\n\t// Walk the currently suspended children in order, calling their\n\t// stored callbacks on the way. Stop if we encounter a child that\n\t// has not been completely resolved yet.\n\tnode = list._next;\n\twhile (node) {\n\t\twhile (node.length > 3) {\n\t\t\tnode.pop()();\n\t\t}\n\t\tif (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {\n\t\t\tbreak;\n\t\t}\n\t\tlist._next = node = node[NEXT_NODE];\n\t}\n};\n\n// Things we do here to save some bytes but are not proper JS inheritance:\n// - call `new Component()` as the prototype\n// - do not set `Suspense.prototype.constructor` to `Suspense`\nSuspenseList.prototype = new Component();\n\nSuspenseList.prototype._suspended = function (child) {\n\tconst list = this;\n\tconst delegated = suspended(list._vnode);\n\n\tlet node = list._map.get(child);\n\tnode[SUSPENDED_COUNT]++;\n\n\treturn unsuspend => {\n\t\tconst wrappedUnsuspend = () => {\n\t\t\tif (!list.props.revealOrder) {\n\t\t\t\t// Special case the undefined (falsy) revealOrder, as there\n\t\t\t\t// is no need to coordinate a specific order or unsuspends.\n\t\t\t\tunsuspend();\n\t\t\t} else {\n\t\t\t\tnode.push(unsuspend);\n\t\t\t\tresolve(list, child, node);\n\t\t\t}\n\t\t};\n\t\tif (delegated) {\n\t\t\tdelegated(wrappedUnsuspend);\n\t\t} else {\n\t\t\twrappedUnsuspend();\n\t\t}\n\t};\n};\n\nSuspenseList.prototype.render = function (props) {\n\tthis._next = null;\n\tthis._map = new Map();\n\n\tconst children = toChildArray(props.children);\n\tif (props.revealOrder && props.revealOrder[0] === 'b') {\n\t\t// If order === 'backwards' (or, well, anything starting with a 'b')\n\t\t// then flip the child list around so that the last child will be\n\t\t// the first in the linked list.\n\t\tchildren.reverse();\n\t}\n\t// Build the linked list. Iterate through the children in reverse order\n\t// so that `_next` points to the first linked list node to be resolved.\n\tfor (let i = children.length; i--; ) {\n\t\t// Create a new linked list node as an array of form:\n\t\t// \t[suspended_count, resolved_count, next_node]\n\t\t// where suspended_count and resolved_count are numeric counters for\n\t\t// keeping track how many times a node has been suspended and resolved.\n\t\t//\n\t\t// Note that suspended_count starts from 1 instead of 0, so we can block\n\t\t// processing callbacks until componentDidMount has been called. In a sense\n\t\t// node is suspended at least until componentDidMount gets called!\n\t\t//\n\t\t// Pending callbacks are added to the end of the node:\n\t\t// \t[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]\n\t\tthis._map.set(children[i], (this._next = [1, 0, this._next]));\n\t}\n\treturn props.children;\n};\n\nSuspenseList.prototype.componentDidUpdate =\n\tSuspenseList.prototype.componentDidMount = function () {\n\t\t// Iterate through all children after mounting for two reasons:\n\t\t// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases\n\t\t//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.\n\t\t//    The nodes can now be completely consumed from the linked list.\n\t\t// 2. Handle nodes that might have gotten resolved between render and\n\t\t//    componentDidMount.\n\t\tthis._map.forEach((node, child) => {\n\t\t\tresolve(this, child, node);\n\t\t});\n\t};\n","/** Normal hydration that attaches to a DOM tree but does not diff it. */\nexport const MODE_HYDRATE = 1 << 5;\n/** Signifies this VNode suspended on the previous render */\nexport const MODE_SUSPENDED = 1 << 7;\n/** Indicates that this node needs to be inserted while patching children */\nexport const INSERT_VNODE = 1 << 16;\n/** Indicates a VNode has been matched with another VNode in the diff */\nexport const MATCHED = 1 << 17;\n\n/** Reset all mode flags */\nexport const RESET_MODE = ~(MODE_HYDRATE | MODE_SUSPENDED);\n\nexport const EMPTY_OBJ = /** @type {any} */ ({});\nexport const EMPTY_ARR = [];\nexport const IS_NON_DIMENSIONAL =\n\t/acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;\n","import { EMPTY_OBJ } from './constants';\nimport { commitRoot, diff } from './diff/index';\nimport { createElement, Fragment } from './create-element';\nimport options from './options';\nimport { slice } from './util';\n\n/**\n * Render a Preact virtual node into a DOM element\n * @param {ComponentChild} vnode The virtual node to render\n * @param {PreactElement} parentDom The DOM element to render into\n * @param {PreactElement | object} [replaceNode] Optional: Attempt to re-use an\n * existing DOM tree rooted at `replaceNode`\n */\nexport function render(vnode, parentDom, replaceNode) {\n\tif (options._root) options._root(vnode, parentDom);\n\n\t// We abuse the `replaceNode` parameter in `hydrate()` to signal if we are in\n\t// hydration mode or not by passing the `hydrate` function instead of a DOM\n\t// element..\n\tlet isHydrating = typeof replaceNode == 'function';\n\n\t// To be able to support calling `render()` multiple times on the same\n\t// DOM node, we need to obtain a reference to the previous tree. We do\n\t// this by assigning a new `_children` property to DOM nodes which points\n\t// to the last rendered tree. By default this property is not present, which\n\t// means that we are mounting a new tree for the first time.\n\tlet oldVNode = isHydrating\n\t\t? null\n\t\t: (replaceNode && replaceNode._children) || parentDom._children;\n\n\tvnode = ((!isHydrating && replaceNode) || parentDom)._children =\n\t\tcreateElement(Fragment, null, [vnode]);\n\n\t// List of effects that need to be called after diffing.\n\tlet commitQueue = [],\n\t\trefQueue = [];\n\tdiff(\n\t\tparentDom,\n\t\t// Determine the new vnode tree and store it on the DOM element on\n\t\t// our custom `_children` property.\n\t\tvnode,\n\t\toldVNode || EMPTY_OBJ,\n\t\tEMPTY_OBJ,\n\t\tparentDom.ownerSVGElement !== undefined,\n\t\t!isHydrating && replaceNode\n\t\t\t? [replaceNode]\n\t\t\t: oldVNode\n\t\t\t? null\n\t\t\t: parentDom.firstChild\n\t\t\t? slice.call(parentDom.childNodes)\n\t\t\t: null,\n\t\tcommitQueue,\n\t\t!isHydrating && replaceNode\n\t\t\t? replaceNode\n\t\t\t: oldVNode\n\t\t\t? oldVNode._dom\n\t\t\t: parentDom.firstChild,\n\t\tisHydrating,\n\t\trefQueue\n\t);\n\n\t// Flush all queued effects\n\tcommitRoot(commitQueue, vnode, refQueue);\n}\n\n/**\n * Update an existing DOM element with data from a Preact virtual node\n * @param {ComponentChild} vnode The virtual node to render\n * @param {PreactElement} parentDom The DOM element to update\n */\nexport function hydrate(vnode, parentDom) {\n\trender(vnode, parentDom, hydrate);\n}\n","import './scss/index.scss'\nimport WhatsappLogo from '../assets/svg/whatsapp.svg'\n\nimport { Fragment, render } from 'preact';\n\nconst App = () => {\n  return (\n    <>\n      <header className=\"Header\">\n        <div className=\"Brand\">\n          <div className=\"Title\">Lluis Colomer</div>\n          <div className=\"Subtitle\">Fisioterapia, Osteopatía y Acupuntura</div>\n        </div>\n      </header>\n      <div className=\"Body\">\n        <div className=\"Content\">\n          <section className=\"Section Main\">\n            <div className=\"Background\">\n              <svg id=\"Layer_2\" xmlns=\"http://www.w3.org/2000/svg\" width=\"791.97\" height=\"724.66\" viewBox=\"0 0 791.97 724.66\">\n                <defs>\n                <linearGradient id=\"gradient\" x1=\"0%\" y1=\"0%\" x2=\"100%\" y2=\"0%\">\n                  <stop offset=\"0%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0\" />\n                  <stop offset=\"10%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0.1\" />\n                  <stop offset=\"100%\" style=\"stop-color:rgb(255,255,255); stop-opacity:0.4\" />\n                </linearGradient>\n              </defs>\n                <circle cx=\"395.83\" cy=\"360.83\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"145.23\" cy=\"360.83\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"395.83\" cy=\"505.56\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"646.74\" cy=\"360.83\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"520.9\" cy=\"289.96\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"269.3\" cy=\"289.96\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"520.9\" cy=\"579.43\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"269.3\" cy=\"579.43\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"395.83\" cy=\"216.1\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"520.9\" cy=\"434.69\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"269.3\" cy=\"434.69\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"269.3\" cy=\"145.23\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" />\n                <circle cx=\"520.9\" cy=\"145.23\" r=\"144.73\" stroke=\"url(#gradient)\" fill=\"none\" /></svg>\n            </div>\n            <div className=\"Text\">\n              Bienvenido a nuestro centro de terapias integrales, donde combinamos fisioterapia, osteopatía y acupuntura para ofrecerte un cuidado completo orientado al alto rendimiento deportivo y a la salud general. Especializados en la rehabilitación de lesiones deportivas, tratamiento del dolor y reequilibrio energético, nuestro objetivo es guiarte hacia un estado de bienestar integral.\n            </div>\n          </section>\n          <section className=\"Section Performance\">\n            <div className=\"Title\">Alto rendimiento deportivo</div>\n            <div className=\"Text\">Con experiencia en los Juegos Olímpicos de Beijing y el circuito profesional de tenis ATP-WTA, nuestro enfoque se centra en maximizar tu rendimiento deportivo. Ofrecemos programas personalizados de rehabilitación y prevención de lesiones, asegurando que estés siempre en tu mejor forma.</div>\n          </section>\n          <section className=\"Section Injuries\">\n            <div className=\"Title\">Rehabilitación de Lesiones Deportivas</div>\n            <div className=\"Text\">Utilizamos técnicas avanzadas de fisioterapia y osteopatía para una recuperación óptima de lesiones deportivas. Nuestro enfoque integral acelera el proceso de curación, minimiza el riesgo de relesiones y mejora tu movilidad y fuerza.</div>\n          </section>\n          <section className=\"Section Pain\">\n            <div className=\"Title\">Alivio del Dolor</div>\n            <div className=\"Text\">Nuestros tratamientos están diseñados para aliviar dolores musculares, articulares y somatizaciones físicas causadas por el estrés. A través de la acupuntura, osteopatía y técnicas especializadas, te ayudamos a liberarte del dolor y mejorar tu calidad de vida.</div>\n          </section>\n          <section className=\"Section Health\">\n            <div className=\"Title\">Bienestar Integral</div>\n            <div className=\"Text\">Más allá del rendimiento deportivo y la rehabilitación, ofrecemos tratamientos para mejorar tu bienestar general, incluyendo insomnio, ansiedad, tinnitus, cuestiones ginecológicas y emocionales. Nuestra aproximación holística te ayuda a lograr un equilibrio entre cuerpo y mente.</div>\n          </section>\n          <section className=\"Section Energy\">\n            <div className=\"Title\">Reequilibrio Postural y Energético</div>\n            <div className=\"Text\">A través de una valoración y reequilibrio postural personalizados, identificamos y corregimos desbalances que puedan afectar tu salud y rendimiento. Además, nuestros tratamientos de reequilibrio energético promueven una circulación energética óptima, vital para tu bienestar emocional y físico.</div>\n          </section>\n        </div>\n        <div className=\"Section CallToAction\">\n          <div className=\"Text\">¿Listo para comenzar tu camino hacia el bienestar? Contáctanos para agendar tu cita o saber más sobre nuestros servicios.\n            <p>Estamos ubicados en:</p><p><a href=\"https://maps.app.goo.gl/TexggBEW42X1wm5QA\">Carrer de francesc Carbonell 35 baixos 08034, Barcelona</a>.</p>\n            <p className=\"Bye\">¡Esperamos verte pronto!</p>\n            <a href=\"https://wa.me/34663407440?text=Hola! Me gustaría pedir cita\" target=\"_blank\" className=\"Whatsapp__Wrapper\">\n              <div className=\"Whatsapp\">\n                <WhatsappLogo />\n                <div className=\"Text\">Pide tu cita por WhatsApp</div>\n              </div>\n            </a>\n          </div>\n        </div>\n\n      </div>\n      <footer className=\"Footer\">\n        <div className=\"Text\">© 2024 Lluis Colomer. Todos los derechos reservados.</div>\n      </footer>\n    </>\n  );\n}\n\nrender(App(), document.body);","import React from \"react\";\nexport default (({\n  styles = {},\n  ...props\n}) => <svg height=\"800\" width=\"800\" xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 308 308\" {...props}><path d=\"M227.904 176.981c-.6-.288-23.054-11.345-27.044-12.781-1.629-.585-3.374-1.156-5.23-1.156-3.032 0-5.579 1.511-7.563 4.479-2.243 3.334-9.033 11.271-11.131 13.642-.274.313-.648.687-.872.687-.201 0-3.676-1.431-4.728-1.888-24.087-10.463-42.37-35.624-44.877-39.867-.358-.61-.373-.887-.376-.887.088-.323.898-1.135 1.316-1.554 1.223-1.21 2.548-2.805 3.83-4.348a140.77 140.77 0 011.812-2.153c1.86-2.164 2.688-3.844 3.648-5.79l.503-1.011c2.344-4.657.342-8.587-.305-9.856-.531-1.062-10.012-23.944-11.02-26.348-2.424-5.801-5.627-8.502-10.078-8.502-.413 0 0 0-1.732.073-2.109.089-13.594 1.601-18.672 4.802C90 87.918 80.89 98.74 80.89 117.772c0 17.129 10.87 33.302 15.537 39.453.116.155.329.47.638.922 17.873 26.102 40.154 45.446 62.741 54.469 21.745 8.686 32.042 9.69 37.896 9.69h.001c2.46 0 4.429-.193 6.166-.364l1.102-.105c7.512-.666 24.02-9.22 27.775-19.655 2.958-8.219 3.738-17.199 1.77-20.458-1.348-2.216-3.671-3.331-6.612-4.743z\" /><path d=\"M156.734 0C73.318 0 5.454 67.354 5.454 150.143c0 26.777 7.166 52.988 20.741 75.928L.212 302.716a3.998 3.998 0 004.999 5.096l79.92-25.396c21.87 11.685 46.588 17.853 71.604 17.853C240.143 300.27 308 232.923 308 150.143 308 67.354 240.143 0 156.734 0zm0 268.994c-23.539 0-46.338-6.797-65.936-19.657a3.996 3.996 0 00-3.406-.467l-40.035 12.726 12.924-38.129a4.002 4.002 0 00-.561-3.647c-14.924-20.392-22.813-44.485-22.813-69.677 0-65.543 53.754-118.867 119.826-118.867 66.064 0 119.812 53.324 119.812 118.867.001 65.535-53.746 118.851-119.811 118.851z\" /></svg>);"],"names":["module","exports","cssWithMappingToString","list","toString","this","map","item","content","needLayer","concat","length","join","i","modules","media","dedupe","supports","layer","undefined","alreadyImportedModules","k","id","_k","push","cssMapping","btoa","base64","unescape","encodeURIComponent","JSON","stringify","data","sourceMapping","sourceURLs","sources","source","sourceRoot","___CSS_LOADER_EXPORT___","stylesInDOM","getIndexByIdentifier","identifier","result","modulesToDom","options","idCountMap","identifiers","base","count","indexByIdentifier","obj","css","sourceMap","references","updater","addElementStyle","byIndex","splice","api","domAPI","update","newObj","remove","lastIdentifiers","newList","index","newLastIdentifiers","_i","_index","memo","insert","style","target","styleTarget","document","querySelector","window","HTMLIFrameElement","contentDocument","head","e","getTarget","Error","appendChild","element","createElement","setAttributes","attributes","styleElement","nonce","setAttribute","insertStyleElement","styleTagTransform","apply","parentNode","removeChild","removeStyleElement","styleSheet","cssText","firstChild","createTextNode","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","n","getter","__esModule","d","a","definition","key","o","Object","defineProperty","enumerable","get","prop","prototype","hasOwnProperty","call","MODE_HYDRATE","slice","vnodeId","rerenderQueue","prevDebounce","defer","depthSort","EMPTY_OBJ","EMPTY_ARR","IS_NON_DIMENSIONAL","isArray","Array","assign","props","removeNode","node","type","children","ref","normalizedProps","arguments","defaultProps","createVNode","original","vnode","__k","__","__b","__e","__d","__c","constructor","__v","__i","__u","Fragment","BaseComponent","context","getDomSibling","childIndex","sibling","updateParentDomPointers","child","enqueueRender","c","process","debounceRendering","renderQueueLength","component","newVNode","oldVNode","oldDom","parentDom","commitQueue","refQueue","sort","shift","__P","diff","__n","ownerSVGElement","commitRoot","diffChildren","renderResult","newParentVNode","oldParentVNode","globalContext","isSvg","excessDomChildren","isHydrating","childVNode","newDom","firstChildDom","oldChildren","newChildrenLength","constructNewChildrenArray","applyRef","nextSibling","skewedIndex","matchingIndex","oldChildrenLength","remainingOldChildren","skew","String","findMatchingIndex","unmount","parentVNode","insertBefore","nodeType","toChildArray","out","some","x","y","setStyle","value","setProperty","test","dom","name","oldValue","useCapture","replace","toLowerCase","l","_attached","Date","now","addEventListener","eventProxyCapture","eventProxy","removeEventListener","removeAttribute","eventHandler","_dispatched","event","tmp","isNew","oldProps","oldState","snapshot","clearProcessingException","newProps","provider","componentContext","renderHook","newType","outer","contextType","__E","render","doRender","sub","state","__h","_sb","getDerivedStateFromProps","__s","componentWillMount","componentDidMount","componentWillReceiveProps","shouldComponentUpdate","forEach","componentWillUpdate","componentDidUpdate","__r","getChildContext","getSnapshotBeforeUpdate","indexOf","diffElementNodes","diffed","root","cb","newHtml","oldHtml","newChildren","inputValue","checked","localName","createElementNS","is","childNodes","__html","innerHTML","current","skipRemove","r","componentWillUnmount","error","errorInfo","ctor","handled","getDerivedStateFromError","setState","componentDidCatch","callback","s","forceUpdate","Promise","then","bind","resolve","setTimeout","b","currentComponent","previousComponent","prevRaf","afterPaintEffects","EMPTY","_options","oldBeforeDiff","oldBeforeRender","oldAfterDiff","oldCommit","oldBeforeUnmount","oldRoot","flushAfterPaintEffects","__H","invokeCleanup","invokeEffect","__m","hooks","hookItem","__N","_pendingArgs","requestAnimationFrame","afterNextFrame","__V","filter","hasErrored","HAS_RAF","raf","done","clearTimeout","timeout","cancelAnimationFrame","hook","comp","cleanup","shallowDiffers","PureComponent","p","Component","isPureReactComponent","oldDiffHook","__f","Symbol","for","oldCatchError","oldUnmount","detachedClone","detachedParent","effect","removeOriginal","originalParent","Suspense","_suspenders","suspended","__a","SuspenseList","_next","_map","__R","promise","suspendingVNode","suspendingComponent","resolved","onResolved","onSuspensionComplete","suspendedVNode","__O","pop","detachedComponent","fallback","delete","revealOrder","size","delegated","unsuspend","wrappedUnsuspend","Map","reverse","set","_this","REACT_ELEMENT_TYPE","CAMEL_PROPS","ON_ANI","CAMEL_REPLACE","IS_DOM","onChangeInputType","configurable","v","writable","oldEventHook","empty","isPropagationStopped","cancelBubble","isDefaultPrevented","defaultPrevented","persist","nativeEvent","classNameDescriptorNonEnumberable","class","oldVNodeHook","lowerCased","multiple","selected","defaultValue","className","$$typeof","oldDiffed","replaceNode","xmlns","width","height","viewBox","x1","y1","x2","y2","offset","cx","cy","stroke","fill","href","styles","body"],"sourceRoot":""}