{"version":3,"sources":["webpack://fxsWidgets/../node_modules/date-fns/end_of_week/index.js","webpack://fxsWidgets/../node_modules/date-fns/sub_weeks/index.js","webpack://fxsWidgets/../node_modules/date-fns/difference_in_milliseconds/index.js","webpack://fxsWidgets/../node_modules/date-fns/difference_in_seconds/index.js","webpack://fxsWidgets/../node_modules/date-fns/sub_months/index.js","webpack://fxsWidgets/../node_modules/dateformat/lib/dateformat.js","webpack://fxsWidgets/../node_modules/date-fns/add_days/index.js","webpack://fxsWidgets/../node_modules/date-fns/add_milliseconds/index.js","webpack://fxsWidgets/../node_modules/date-fns/difference_in_hours/index.js","webpack://fxsWidgets/../node_modules/date-fns/get_days_in_month/index.js","webpack://fxsWidgets/../node_modules/unistore/src/util.js","webpack://fxsWidgets/../node_modules/unistore/src/index.js","webpack://fxsWidgets/../node_modules/date-fns/start_of_month/index.js","webpack://fxsWidgets/../node_modules/prop-types/lib/ReactPropTypesSecret.js","webpack://fxsWidgets/../node_modules/date-fns/add_minutes/index.js","webpack://fxsWidgets/../node_modules/date-fns/start_of_day/index.js","webpack://fxsWidgets/../node_modules/date-fns/start_of_week/index.js","webpack://fxsWidgets/../node_modules/date-fns/is_after/index.js","webpack://fxsWidgets/../node_modules/date-fns/is_date/index.js","webpack://fxsWidgets/../node_modules/date-fns/add_months/index.js","webpack://fxsWidgets/../node_modules/date-fns/_lib/getTimezoneOffsetInMilliseconds/index.js","webpack://fxsWidgets/../node_modules/prop-types/factoryWithThrowingShims.js","webpack://fxsWidgets/../node_modules/date-fns/sub_minutes/index.js","webpack://fxsWidgets/../node_modules/date-fns/parse/index.js","webpack://fxsWidgets/../node_modules/date-fns/end_of_month/index.js","webpack://fxsWidgets/../node_modules/unistore/src/integrations/preact.js","webpack://fxsWidgets/../node_modules/prop-types/index.js","webpack://fxsWidgets/../node_modules/unistore/devtools.js","webpack://fxsWidgets/../node_modules/date-fns/sub_days/index.js","webpack://fxsWidgets/../node_modules/date-fns/is_same_day/index.js","webpack://fxsWidgets/../node_modules/preact/src/util.js","webpack://fxsWidgets/../node_modules/preact/src/create-element.js","webpack://fxsWidgets/../node_modules/preact/src/component.js","webpack://fxsWidgets/../node_modules/preact/src/constants.js","webpack://fxsWidgets/../node_modules/preact/src/diff/children.js","webpack://fxsWidgets/../node_modules/preact/src/diff/props.js","webpack://fxsWidgets/../node_modules/preact/src/diff/index.js","webpack://fxsWidgets/../node_modules/preact/src/render.js","webpack://fxsWidgets/../node_modules/preact/src/clone-element.js","webpack://fxsWidgets/../node_modules/preact/src/create-context.js","webpack://fxsWidgets/../node_modules/preact/src/options.js","webpack://fxsWidgets/../node_modules/preact/src/diff/catch-error.js","webpack://fxsWidgets/../node_modules/preact/hooks/src/index.js","webpack://fxsWidgets/../node_modules/preact/compat/src/util.js","webpack://fxsWidgets/../node_modules/preact/compat/src/PureComponent.js","webpack://fxsWidgets/../node_modules/preact/compat/src/memo.js","webpack://fxsWidgets/../node_modules/preact/compat/src/forwardRef.js","webpack://fxsWidgets/../node_modules/preact/compat/src/suspense.js","webpack://fxsWidgets/../node_modules/preact/compat/src/suspense-list.js","webpack://fxsWidgets/../node_modules/preact/compat/src/portals.js","webpack://fxsWidgets/../node_modules/preact/compat/src/render.js","webpack://fxsWidgets/../node_modules/preact/compat/src/index.js","webpack://fxsWidgets/../node_modules/preact/compat/src/Children.js","webpack://fxsWidgets/../node_modules/date-fns/end_of_day/index.js","webpack://fxsWidgets/../node_modules/date-fns/add_hours/index.js","webpack://fxsWidgets/../node_modules/date-fns/add_seconds/index.js","webpack://fxsWidgets/../node_modules/date-fns/is_before/index.js","webpack://fxsWidgets/../node_modules/date-fns/add_weeks/index.js"],"names":["parse","require","module","exports","dirtyDate","dirtyOptions","weekStartsOn","Number","date","day","getDay","diff","setDate","getDate","setHours","addWeeks","dirtyAmount","amount","dirtyDateLeft","dirtyDateRight","dateLeft","dateRight","getTime","differenceInMilliseconds","Math","floor","ceil","addMonths","pad","val","len","String","length","token","timezone","timezoneClip","dateFormat","mask","utc","gmt","arguments","undefined","_typeof","Array","isArray","toString","call","slice","toLowerCase","test","Date","isNaN","TypeError","maskSlice","masks","_","d","D","m","y","H","M","s","L","o","getTimezoneOffset","W","targetThursday","getFullYear","getMonth","firstThursday","ds","getHours","getWeek","N","dow","getDayOfWeek","flags","dd","ddd","i18n","dayNames","dddd","mm","mmm","monthNames","mmmm","yy","yyyy","h","hh","HH","MM","ss","l","round","t","timeNames","tt","T","TT","Z","match","pop","replace","abs","S","define","timestamp","year","monthIndex","lastDayOfMonth","setFullYear","n","r","u","push","e","f","i","action","apply","this","then","setState","subscribe","unsubscribe","getState","addMilliseconds","dirtyDateToCompare","dateToCompare","argument","getDaysInMonth","desiredMonth","dateWithDesiredMonth","daysInMonth","setMonth","min","baseTimezoneOffset","setSeconds","emptyFunction","emptyFunctionWithReset","ReactPropTypesSecret","resetWarningCache","shim","props","propName","componentName","location","propFullName","secret","err","Error","name","getShim","isRequired","ReactPropTypes","array","bigint","bool","func","number","object","string","symbol","any","arrayOf","element","elementType","instanceOf","node","objectOf","oneOf","oneOfType","shape","exact","checkPropTypes","PropTypes","addMinutes","dayOfISOYear","isoYear","week","setUTCFullYear","getUTCDay","setUTCDate","getUTCDate","getTimezoneOffsetInMilliseconds","isDate","MILLISECONDS_IN_HOUR","MILLISECONDS_IN_MINUTE","parseTokenDateTimeDelimeter","parseTokenPlainTime","parseTokenYY","parseTokensYYY","parseTokenYYYY","parseTokensYYYYY","parseTokenMM","parseTokenDDD","parseTokenMMDD","parseTokenWww","parseTokenWwwD","parseTokenHH","parseTokenHHMM","parseTokenHHMMSS","parseTokenTimezone","parseTokenTimezoneZ","parseTokenTimezoneHH","parseTokenTimezoneHHMM","additionalDigits","dateStrings","dateString","timeString","split","exec","time","splitDateString","parseYearResult","parseTokenYYY","parseTokenYYYYY","yearString","parseInt","restDateString","centuryString","parseYear","month","dayOfYear","parseDate","offset","hours","minutes","parseFloat","seconds","parseTime","timezoneString","absoluteOffset","parseTimezone","fullTime","fullTimeDate","fullTimeDateNextDay","offsetDiff","getChildContext","store","prototype","render","children","connect","c","a","p","componentWillReceiveProps","componentDidMount","componentWillUnmount","Component","constructor","Provider","extension","window","__REDUX_DEVTOOLS_EXTENSION__","top","ignoreState","devtools","message","type","state","payload","JSON","init","send","console","warn","addDays","startOfDay","dateLeftStartOfDay","dateRightStartOfDay","w","parentNode","removeChild","defaultProps","g","key","ref","__k","__","__b","__e","__d","__c","__v","__i","__u","vnode","current","k","b","context","x","C","base","P","__r","debounceRendering","sort","shift","__P","O","__n","namespaceURI","j","v","$","contains","I","nextSibling","V","insertBefore","nodeType","some","setProperty","A","style","cssText","addEventListener","removeEventListener","removeAttribute","setAttribute","F","event","contextType","value","__E","q","sub","__h","_sb","__s","getDerivedStateFromProps","componentWillMount","shouldComponentUpdate","forEach","componentWillUpdate","componentDidUpdate","getSnapshotBeforeUpdate","indexOf","z","diffed","localName","document","createTextNode","createElementNS","is","data","childNodes","attributes","__html","innerHTML","unmount","B","firstChild","E","G","Consumer","splice","getDerivedStateFromError","componentDidCatch","forceUpdate","Promise","bind","resolve","setTimeout","__H","__N","filter","every","concat","useDebugValue","__m","clearTimeout","cancelAnimationFrame","requestAnimationFrame","displayName","isReactComponent","__f","$$typeof","map","appendChild","__a","default","U","containerInfo","textContent","K","Q","cancelBubble","X","defaultPrevented","ln","fn","an","sn","startsWith","hn","vn","dn","_n","bn","Sn","Cn","xn","isPureReactComponent","R","Symbol","for","count","only","toArray","__R","__O","createElement","fallback","delete","revealOrder","size","get","Map","reverse","set","Y","Object","defineProperty","configurable","writable","J","persist","isPropagationStopped","isDefaultPrevented","nativeEvent","nn","tn","enumerable","class","en","multiple","selected","defaultValue","className","rn","un","on","ReactCurrentDispatcher","readContext","useCallback","useContext","useDeferredValue","useEffect","useId","useImperativeHandle","useInsertionEffect","gn","useLayoutEffect","useMemo","useReducer","useRef","useState","useSyncExternalStore","useTransition","cn","pn","mn","yn","En","Rn","startTransition","version","Children","hydrate","unmountComponentAtNode","createPortal","createContext","createFactory","cloneElement","createRef","Fragment","isValidElement","isElement","isFragment","isMemo","findDOMNode","PureComponent","memo","forwardRef","flushSync","unstable_batchedUpdates","StrictMode","Suspense","SuspenseList","lazy","__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED"],"mappings":"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","file":"vendor.93592138e6333939d122.js","sourcesContent":["var parse = require('../parse/index.js')\n\n/**\n * @category Week Helpers\n * @summary Return the end of a week for the given date.\n *\n * @description\n * Return the end of a week for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @param {Object} [options] - the object with options\n * @param {Number} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the end of a week\n *\n * @example\n * // The end of a week for 2 September 2014 11:55:00:\n * var result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sat Sep 06 2014 23:59:59.999\n *\n * @example\n * // If the week starts on Monday, the end of the week for 2 September 2014 11:55:00:\n * var result = endOfWeek(new Date(2014, 8, 2, 11, 55, 0), {weekStartsOn: 1})\n * //=> Sun Sep 07 2014 23:59:59.999\n */\nfunction endOfWeek (dirtyDate, dirtyOptions) {\n  var weekStartsOn = dirtyOptions ? (Number(dirtyOptions.weekStartsOn) || 0) : 0\n\n  var date = parse(dirtyDate)\n  var day = date.getDay()\n  var diff = (day < weekStartsOn ? -7 : 0) + 6 - (day - weekStartsOn)\n\n  date.setDate(date.getDate() + diff)\n  date.setHours(23, 59, 59, 999)\n  return date\n}\n\nmodule.exports = endOfWeek\n","var addWeeks = require('../add_weeks/index.js')\n\n/**\n * @category Week Helpers\n * @summary Subtract the specified number of weeks from the given date.\n *\n * @description\n * Subtract the specified number of weeks from the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of weeks to be subtracted\n * @returns {Date} the new date with the weeks subtracted\n *\n * @example\n * // Subtract 4 weeks from 1 September 2014:\n * var result = subWeeks(new Date(2014, 8, 1), 4)\n * //=> Mon Aug 04 2014 00:00:00\n */\nfunction subWeeks (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addWeeks(dirtyDate, -amount)\n}\n\nmodule.exports = subWeeks\n","var parse = require('../parse/index.js')\n\n/**\n * @category Millisecond Helpers\n * @summary Get the number of milliseconds between the given dates.\n *\n * @description\n * Get the number of milliseconds between the given dates.\n *\n * @param {Date|String|Number} dateLeft - the later date\n * @param {Date|String|Number} dateRight - the earlier date\n * @returns {Number} the number of milliseconds\n *\n * @example\n * // How many milliseconds are between\n * // 2 July 2014 12:30:20.600 and 2 July 2014 12:30:21.700?\n * var result = differenceInMilliseconds(\n *   new Date(2014, 6, 2, 12, 30, 21, 700),\n *   new Date(2014, 6, 2, 12, 30, 20, 600)\n * )\n * //=> 1100\n */\nfunction differenceInMilliseconds (dirtyDateLeft, dirtyDateRight) {\n  var dateLeft = parse(dirtyDateLeft)\n  var dateRight = parse(dirtyDateRight)\n  return dateLeft.getTime() - dateRight.getTime()\n}\n\nmodule.exports = differenceInMilliseconds\n","var differenceInMilliseconds = require('../difference_in_milliseconds/index.js')\n\n/**\n * @category Second Helpers\n * @summary Get the number of seconds between the given dates.\n *\n * @description\n * Get the number of seconds between the given dates.\n *\n * @param {Date|String|Number} dateLeft - the later date\n * @param {Date|String|Number} dateRight - the earlier date\n * @returns {Number} the number of seconds\n *\n * @example\n * // How many seconds are between\n * // 2 July 2014 12:30:07.999 and 2 July 2014 12:30:20.000?\n * var result = differenceInSeconds(\n *   new Date(2014, 6, 2, 12, 30, 20, 0),\n *   new Date(2014, 6, 2, 12, 30, 7, 999)\n * )\n * //=> 12\n */\nfunction differenceInSeconds (dirtyDateLeft, dirtyDateRight) {\n  var diff = differenceInMilliseconds(dirtyDateLeft, dirtyDateRight) / 1000\n  return diff > 0 ? Math.floor(diff) : Math.ceil(diff)\n}\n\nmodule.exports = differenceInSeconds\n","var addMonths = require('../add_months/index.js')\n\n/**\n * @category Month Helpers\n * @summary Subtract the specified number of months from the given date.\n *\n * @description\n * Subtract the specified number of months from the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of months to be subtracted\n * @returns {Date} the new date with the months subtracted\n *\n * @example\n * // Subtract 5 months from 1 February 2015:\n * var result = subMonths(new Date(2015, 1, 1), 5)\n * //=> Mon Sep 01 2014 00:00:00\n */\nfunction subMonths (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addMonths(dirtyDate, -amount)\n}\n\nmodule.exports = subMonths\n","/*\n * Date Format 1.2.3\n * (c) 2007-2009 Steven Levithan <stevenlevithan.com>\n * MIT license\n *\n * Includes enhancements by Scott Trenda <scott.trenda.net>\n * and Kris Kowal <cixar.com/~kris.kowal/>\n *\n * Accepts a date, a mask, or a date and a mask.\n * Returns a formatted version of the given date.\n * The date defaults to the current date/time.\n * The mask defaults to dateFormat.masks.default.\n */\n\n(function(global) {\n  'use strict';\n\n  var dateFormat = (function() {\n      var token = /d{1,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\\1?|[LloSZWN]|\"[^\"]*\"|'[^']*'/g;\n      var timezone = /\\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\\d{4})?)\\b/g;\n      var timezoneClip = /[^-+\\dA-Z]/g;\n  \n      // Regexes and supporting functions are cached through closure\n      return function (date, mask, utc, gmt) {\n  \n        // You can't provide utc if you skip other args (use the 'UTC:' mask prefix)\n        if (arguments.length === 1 && kindOf(date) === 'string' && !/\\d/.test(date)) {\n          mask = date;\n          date = undefined;\n        }\n  \n        date = date || new Date;\n  \n        if(!(date instanceof Date)) {\n          date = new Date(date);\n        }\n  \n        if (isNaN(date)) {\n          throw TypeError('Invalid date');\n        }\n  \n        mask = String(dateFormat.masks[mask] || mask || dateFormat.masks['default']);\n  \n        // Allow setting the utc/gmt argument via the mask\n        var maskSlice = mask.slice(0, 4);\n        if (maskSlice === 'UTC:' || maskSlice === 'GMT:') {\n          mask = mask.slice(4);\n          utc = true;\n          if (maskSlice === 'GMT:') {\n            gmt = true;\n          }\n        }\n  \n        var _ = utc ? 'getUTC' : 'get';\n        var d = date[_ + 'Date']();\n        var D = date[_ + 'Day']();\n        var m = date[_ + 'Month']();\n        var y = date[_ + 'FullYear']();\n        var H = date[_ + 'Hours']();\n        var M = date[_ + 'Minutes']();\n        var s = date[_ + 'Seconds']();\n        var L = date[_ + 'Milliseconds']();\n        var o = utc ? 0 : date.getTimezoneOffset();\n        var W = getWeek(date);\n        var N = getDayOfWeek(date);\n        var flags = {\n          d:    d,\n          dd:   pad(d),\n          ddd:  dateFormat.i18n.dayNames[D],\n          dddd: dateFormat.i18n.dayNames[D + 7],\n          m:    m + 1,\n          mm:   pad(m + 1),\n          mmm:  dateFormat.i18n.monthNames[m],\n          mmmm: dateFormat.i18n.monthNames[m + 12],\n          yy:   String(y).slice(2),\n          yyyy: y,\n          h:    H % 12 || 12,\n          hh:   pad(H % 12 || 12),\n          H:    H,\n          HH:   pad(H),\n          M:    M,\n          MM:   pad(M),\n          s:    s,\n          ss:   pad(s),\n          l:    pad(L, 3),\n          L:    pad(Math.round(L / 10)),\n          t:    H < 12 ? dateFormat.i18n.timeNames[0] : dateFormat.i18n.timeNames[1],\n          tt:   H < 12 ? dateFormat.i18n.timeNames[2] : dateFormat.i18n.timeNames[3],\n          T:    H < 12 ? dateFormat.i18n.timeNames[4] : dateFormat.i18n.timeNames[5],\n          TT:   H < 12 ? dateFormat.i18n.timeNames[6] : dateFormat.i18n.timeNames[7],\n          Z:    gmt ? 'GMT' : utc ? 'UTC' : (String(date).match(timezone) || ['']).pop().replace(timezoneClip, ''),\n          o:    (o > 0 ? '-' : '+') + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4),\n          S:    ['th', 'st', 'nd', 'rd'][d % 10 > 3 ? 0 : (d % 100 - d % 10 != 10) * d % 10],\n          W:    W,\n          N:    N\n        };\n  \n        return mask.replace(token, function (match) {\n          if (match in flags) {\n            return flags[match];\n          }\n          return match.slice(1, match.length - 1);\n        });\n      };\n    })();\n\n  dateFormat.masks = {\n    'default':               'ddd mmm dd yyyy HH:MM:ss',\n    'shortDate':             'm/d/yy',\n    'mediumDate':            'mmm d, yyyy',\n    'longDate':              'mmmm d, yyyy',\n    'fullDate':              'dddd, mmmm d, yyyy',\n    'shortTime':             'h:MM TT',\n    'mediumTime':            'h:MM:ss TT',\n    'longTime':              'h:MM:ss TT Z',\n    'isoDate':               'yyyy-mm-dd',\n    'isoTime':               'HH:MM:ss',\n    'isoDateTime':           'yyyy-mm-dd\\'T\\'HH:MM:sso',\n    'isoUtcDateTime':        'UTC:yyyy-mm-dd\\'T\\'HH:MM:ss\\'Z\\'',\n    'expiresHeaderFormat':   'ddd, dd mmm yyyy HH:MM:ss Z'\n  };\n\n  // Internationalization strings\n  dateFormat.i18n = {\n    dayNames: [\n      'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat',\n      'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'\n    ],\n    monthNames: [\n      'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec',\n      'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'\n    ],\n    timeNames: [\n      'a', 'p', 'am', 'pm', 'A', 'P', 'AM', 'PM'\n    ]\n  };\n\nfunction pad(val, len) {\n  val = String(val);\n  len = len || 2;\n  while (val.length < len) {\n    val = '0' + val;\n  }\n  return val;\n}\n\n/**\n * Get the ISO 8601 week number\n * Based on comments from\n * http://techblog.procurios.nl/k/n618/news/view/33796/14863/Calculate-ISO-8601-week-and-year-in-javascript.html\n *\n * @param  {Object} `date`\n * @return {Number}\n */\nfunction getWeek(date) {\n  // Remove time components of date\n  var targetThursday = new Date(date.getFullYear(), date.getMonth(), date.getDate());\n\n  // Change date to Thursday same week\n  targetThursday.setDate(targetThursday.getDate() - ((targetThursday.getDay() + 6) % 7) + 3);\n\n  // Take January 4th as it is always in week 1 (see ISO 8601)\n  var firstThursday = new Date(targetThursday.getFullYear(), 0, 4);\n\n  // Change date to Thursday same week\n  firstThursday.setDate(firstThursday.getDate() - ((firstThursday.getDay() + 6) % 7) + 3);\n\n  // Check if daylight-saving-time-switch occurred and correct for it\n  var ds = targetThursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();\n  targetThursday.setHours(targetThursday.getHours() - ds);\n\n  // Number of weeks between target Thursday and first Thursday\n  var weekDiff = (targetThursday - firstThursday) / (86400000*7);\n  return 1 + Math.floor(weekDiff);\n}\n\n/**\n * Get ISO-8601 numeric representation of the day of the week\n * 1 (for Monday) through 7 (for Sunday)\n * \n * @param  {Object} `date`\n * @return {Number}\n */\nfunction getDayOfWeek(date) {\n  var dow = date.getDay();\n  if(dow === 0) {\n    dow = 7;\n  }\n  return dow;\n}\n\n/**\n * kind-of shortcut\n * @param  {*} val\n * @return {String}\n */\nfunction kindOf(val) {\n  if (val === null) {\n    return 'null';\n  }\n\n  if (val === undefined) {\n    return 'undefined';\n  }\n\n  if (typeof val !== 'object') {\n    return typeof val;\n  }\n\n  if (Array.isArray(val)) {\n    return 'array';\n  }\n\n  return {}.toString.call(val)\n    .slice(8, -1).toLowerCase();\n};\n\n\n\n  if (typeof define === 'function' && define.amd) {\n    define(function () {\n      return dateFormat;\n    });\n  } else if (typeof exports === 'object') {\n    module.exports = dateFormat;\n  } else {\n    global.dateFormat = dateFormat;\n  }\n})(this);\n","var parse = require('../parse/index.js')\n\n/**\n * @category Day Helpers\n * @summary Add the specified number of days to the given date.\n *\n * @description\n * Add the specified number of days to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be added\n * @returns {Date} the new date with the days added\n *\n * @example\n * // Add 10 days to 1 September 2014:\n * var result = addDays(new Date(2014, 8, 1), 10)\n * //=> Thu Sep 11 2014 00:00:00\n */\nfunction addDays (dirtyDate, dirtyAmount) {\n  var date = parse(dirtyDate)\n  var amount = Number(dirtyAmount)\n  date.setDate(date.getDate() + amount)\n  return date\n}\n\nmodule.exports = addDays\n","var parse = require('../parse/index.js')\n\n/**\n * @category Millisecond Helpers\n * @summary Add the specified number of milliseconds to the given date.\n *\n * @description\n * Add the specified number of milliseconds to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of milliseconds to be added\n * @returns {Date} the new date with the milliseconds added\n *\n * @example\n * // Add 750 milliseconds to 10 July 2014 12:45:30.000:\n * var result = addMilliseconds(new Date(2014, 6, 10, 12, 45, 30, 0), 750)\n * //=> Thu Jul 10 2014 12:45:30.750\n */\nfunction addMilliseconds (dirtyDate, dirtyAmount) {\n  var timestamp = parse(dirtyDate).getTime()\n  var amount = Number(dirtyAmount)\n  return new Date(timestamp + amount)\n}\n\nmodule.exports = addMilliseconds\n","var differenceInMilliseconds = require('../difference_in_milliseconds/index.js')\n\nvar MILLISECONDS_IN_HOUR = 3600000\n\n/**\n * @category Hour Helpers\n * @summary Get the number of hours between the given dates.\n *\n * @description\n * Get the number of hours between the given dates.\n *\n * @param {Date|String|Number} dateLeft - the later date\n * @param {Date|String|Number} dateRight - the earlier date\n * @returns {Number} the number of hours\n *\n * @example\n * // How many hours are between 2 July 2014 06:50:00 and 2 July 2014 19:00:00?\n * var result = differenceInHours(\n *   new Date(2014, 6, 2, 19, 0),\n *   new Date(2014, 6, 2, 6, 50)\n * )\n * //=> 12\n */\nfunction differenceInHours (dirtyDateLeft, dirtyDateRight) {\n  var diff = differenceInMilliseconds(dirtyDateLeft, dirtyDateRight) / MILLISECONDS_IN_HOUR\n  return diff > 0 ? Math.floor(diff) : Math.ceil(diff)\n}\n\nmodule.exports = differenceInHours\n","var parse = require('../parse/index.js')\n\n/**\n * @category Month Helpers\n * @summary Get the number of days in a month of the given date.\n *\n * @description\n * Get the number of days in a month of the given date.\n *\n * @param {Date|String|Number} date - the given date\n * @returns {Number} the number of days in a month\n *\n * @example\n * // How many days are in February 2000?\n * var result = getDaysInMonth(new Date(2000, 1))\n * //=> 29\n */\nfunction getDaysInMonth (dirtyDate) {\n  var date = parse(dirtyDate)\n  var year = date.getFullYear()\n  var monthIndex = date.getMonth()\n  var lastDayOfMonth = new Date(0)\n  lastDayOfMonth.setFullYear(year, monthIndex + 1, 0)\n  lastDayOfMonth.setHours(0, 0, 0, 0)\n  return lastDayOfMonth.getDate()\n}\n\nmodule.exports = getDaysInMonth\n","// Bind an object/factory of actions to the store and wrap them.\nexport function mapActions(actions, store) {\n\tif (typeof actions==='function') actions = actions(store);\n\tlet mapped = {};\n\tfor (let i in actions) {\n\t\tmapped[i] = store.action(actions[i]);\n\t}\n\treturn mapped;\n}\n\n\n// select('foo,bar') creates a function of the form: ({ foo, bar }) => ({ foo, bar })\nexport function select(properties) {\n\tif (typeof properties==='string') properties = properties.split(/\\s*,\\s*/);\n\treturn state => {\n\t\tlet selected = {};\n\t\tfor (let i=0; i<properties.length; i++) {\n\t\t\tselected[properties[i]] = state[properties[i]];\n\t\t}\n\t\treturn selected;\n\t};\n}\n\n\n// Lighter Object.assign stand-in\nexport function assign(obj, props) {\n\tfor (let i in props) obj[i] = props[i];\n\treturn obj;\n}\n","import { assign } from './util';\n\n/**\n * Creates a new store, which is a tiny evented state container.\n * @name createStore\n * @param {Object} [state={}]\t\tOptional initial state\n * @returns {store}\n * @example\n * let store = createStore();\n * store.subscribe( state => console.log(state) );\n * store.setState({ a: 'b' });   // logs { a: 'b' }\n * store.setState({ c: 'd' });   // logs { a: 'b', c: 'd' }\n */\nexport default function createStore(state) {\n\tlet listeners = [];\n\tstate = state || {};\n\n\tfunction unsubscribe(listener) {\n\t\tlet out = [];\n\t\tfor (let i=0; i<listeners.length; i++) {\n\t\t\tif (listeners[i]===listener) {\n\t\t\t\tlistener = null;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tout.push(listeners[i]);\n\t\t\t}\n\t\t}\n\t\tlisteners = out;\n\t}\n\n\tfunction setState(update, overwrite, action) {\n\t\tstate = overwrite ? update : assign(assign({}, state), update);\n\t\tlet currentListeners = listeners;\n\t\tfor (let i=0; i<currentListeners.length; i++) currentListeners[i](state, action);\n\t}\n\n\t/**\n\t * An observable state container, returned from {@link createStore}\n\t * @name store\n\t */\n\n\treturn /** @lends store */ {\n\n\t\t/**\n\t\t * Create a bound copy of the given action function.\n\t\t * The bound returned function invokes action() and persists the result back to the store.\n\t\t * If the return value of `action` is a Promise, the resolved value will be used as state.\n\t\t * @param {Function} action\tAn action of the form `action(state, ...args) -> stateUpdate`\n\t\t * @returns {Function} boundAction()\n\t\t */\n\t\taction(action) {\n\t\t\tfunction apply(result) {\n\t\t\t\tsetState(result, false, action);\n\t\t\t}\n\n\t\t\t// Note: perf tests verifying this implementation: https://esbench.com/bench/5a295e6299634800a0349500\n\t\t\treturn function() {\n\t\t\t\tlet args = [state];\n\t\t\t\tfor (let i=0; i<arguments.length; i++) args.push(arguments[i]);\n\t\t\t\tlet ret = action.apply(this, args);\n\t\t\t\tif (ret!=null) {\n\t\t\t\t\tif (ret.then) return ret.then(apply);\n\t\t\t\t\treturn apply(ret);\n\t\t\t\t}\n\t\t\t};\n\t\t},\n\n\t\t/**\n\t\t * Apply a partial state object to the current state, invoking registered listeners.\n\t\t * @param {Object} update\t\t\t\tAn object with properties to be merged into state\n\t\t * @param {Boolean} [overwrite=false]\tIf `true`, update will replace state instead of being merged into it\n\t\t */\n\t\tsetState,\n\n\t\t/**\n\t\t * Register a listener function to be called whenever state is changed. Returns an `unsubscribe()` function.\n\t\t * @param {Function} listener\tA function to call when state changes. Gets passed the new state.\n\t\t * @returns {Function} unsubscribe()\n\t\t */\n\t\tsubscribe(listener) {\n\t\t\tlisteners.push(listener);\n\t\t\treturn () => { unsubscribe(listener); };\n\t\t},\n\n\t\t/**\n\t\t * Remove a previously-registered listener function.\n\t\t * @param {Function} listener\tThe callback previously passed to `subscribe()` that should be removed.\n\t\t * @function\n\t\t */\n\t\tunsubscribe,\n\n\t\t/**\n\t\t * Retrieve the current state object.\n\t\t * @returns {Object} state\n\t\t */\n\t\tgetState() {\n\t\t\treturn state;\n\t\t}\n\t};\n}\n","var parse = require('../parse/index.js')\n\n/**\n * @category Month Helpers\n * @summary Return the start of a month for the given date.\n *\n * @description\n * Return the start of a month for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @returns {Date} the start of a month\n *\n * @example\n * // The start of a month for 2 September 2014 11:55:00:\n * var result = startOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Mon Sep 01 2014 00:00:00\n */\nfunction startOfMonth (dirtyDate) {\n  var date = parse(dirtyDate)\n  date.setDate(1)\n  date.setHours(0, 0, 0, 0)\n  return date\n}\n\nmodule.exports = startOfMonth\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';\n\nmodule.exports = ReactPropTypesSecret;\n","var addMilliseconds = require('../add_milliseconds/index.js')\n\nvar MILLISECONDS_IN_MINUTE = 60000\n\n/**\n * @category Minute Helpers\n * @summary Add the specified number of minutes to the given date.\n *\n * @description\n * Add the specified number of minutes to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of minutes to be added\n * @returns {Date} the new date with the minutes added\n *\n * @example\n * // Add 30 minutes to 10 July 2014 12:00:00:\n * var result = addMinutes(new Date(2014, 6, 10, 12, 0), 30)\n * //=> Thu Jul 10 2014 12:30:00\n */\nfunction addMinutes (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addMilliseconds(dirtyDate, amount * MILLISECONDS_IN_MINUTE)\n}\n\nmodule.exports = addMinutes\n","var parse = require('../parse/index.js')\n\n/**\n * @category Day Helpers\n * @summary Return the start of a day for the given date.\n *\n * @description\n * Return the start of a day for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @returns {Date} the start of a day\n *\n * @example\n * // The start of a day for 2 September 2014 11:55:00:\n * var result = startOfDay(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 02 2014 00:00:00\n */\nfunction startOfDay (dirtyDate) {\n  var date = parse(dirtyDate)\n  date.setHours(0, 0, 0, 0)\n  return date\n}\n\nmodule.exports = startOfDay\n","var parse = require('../parse/index.js')\n\n/**\n * @category Week Helpers\n * @summary Return the start of a week for the given date.\n *\n * @description\n * Return the start of a week for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @param {Object} [options] - the object with options\n * @param {Number} [options.weekStartsOn=0] - the index of the first day of the week (0 - Sunday)\n * @returns {Date} the start of a week\n *\n * @example\n * // The start of a week for 2 September 2014 11:55:00:\n * var result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Sun Aug 31 2014 00:00:00\n *\n * @example\n * // If the week starts on Monday, the start of the week for 2 September 2014 11:55:00:\n * var result = startOfWeek(new Date(2014, 8, 2, 11, 55, 0), {weekStartsOn: 1})\n * //=> Mon Sep 01 2014 00:00:00\n */\nfunction startOfWeek (dirtyDate, dirtyOptions) {\n  var weekStartsOn = dirtyOptions ? (Number(dirtyOptions.weekStartsOn) || 0) : 0\n\n  var date = parse(dirtyDate)\n  var day = date.getDay()\n  var diff = (day < weekStartsOn ? 7 : 0) + day - weekStartsOn\n\n  date.setDate(date.getDate() - diff)\n  date.setHours(0, 0, 0, 0)\n  return date\n}\n\nmodule.exports = startOfWeek\n","var parse = require('../parse/index.js')\n\n/**\n * @category Common Helpers\n * @summary Is the first date after the second one?\n *\n * @description\n * Is the first date after the second one?\n *\n * @param {Date|String|Number} date - the date that should be after the other one to return true\n * @param {Date|String|Number} dateToCompare - the date to compare with\n * @returns {Boolean} the first date is after the second date\n *\n * @example\n * // Is 10 July 1989 after 11 February 1987?\n * var result = isAfter(new Date(1989, 6, 10), new Date(1987, 1, 11))\n * //=> true\n */\nfunction isAfter (dirtyDate, dirtyDateToCompare) {\n  var date = parse(dirtyDate)\n  var dateToCompare = parse(dirtyDateToCompare)\n  return date.getTime() > dateToCompare.getTime()\n}\n\nmodule.exports = isAfter\n","/**\n * @category Common Helpers\n * @summary Is the given argument an instance of Date?\n *\n * @description\n * Is the given argument an instance of Date?\n *\n * @param {*} argument - the argument to check\n * @returns {Boolean} the given argument is an instance of Date\n *\n * @example\n * // Is 'mayonnaise' a Date?\n * var result = isDate('mayonnaise')\n * //=> false\n */\nfunction isDate (argument) {\n  return argument instanceof Date\n}\n\nmodule.exports = isDate\n","var parse = require('../parse/index.js')\nvar getDaysInMonth = require('../get_days_in_month/index.js')\n\n/**\n * @category Month Helpers\n * @summary Add the specified number of months to the given date.\n *\n * @description\n * Add the specified number of months to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of months to be added\n * @returns {Date} the new date with the months added\n *\n * @example\n * // Add 5 months to 1 September 2014:\n * var result = addMonths(new Date(2014, 8, 1), 5)\n * //=> Sun Feb 01 2015 00:00:00\n */\nfunction addMonths (dirtyDate, dirtyAmount) {\n  var date = parse(dirtyDate)\n  var amount = Number(dirtyAmount)\n  var desiredMonth = date.getMonth() + amount\n  var dateWithDesiredMonth = new Date(0)\n  dateWithDesiredMonth.setFullYear(date.getFullYear(), desiredMonth, 1)\n  dateWithDesiredMonth.setHours(0, 0, 0, 0)\n  var daysInMonth = getDaysInMonth(dateWithDesiredMonth)\n  // Set the last day of the new month\n  // if the original date was the last day of the longer month\n  date.setMonth(desiredMonth, Math.min(daysInMonth, date.getDate()))\n  return date\n}\n\nmodule.exports = addMonths\n","var MILLISECONDS_IN_MINUTE = 60000\n\n/**\n * Google Chrome as of 67.0.3396.87 introduced timezones with offset that includes seconds.\n * They usually appear for dates that denote time before the timezones were introduced\n * (e.g. for 'Europe/Prague' timezone the offset is GMT+00:57:44 before 1 October 1891\n * and GMT+01:00:00 after that date)\n *\n * Date#getTimezoneOffset returns the offset in minutes and would return 57 for the example above,\n * which would lead to incorrect calculations.\n *\n * This function returns the timezone offset in milliseconds that takes seconds in account.\n */\nmodule.exports = function getTimezoneOffsetInMilliseconds (dirtyDate) {\n  var date = new Date(dirtyDate.getTime())\n  var baseTimezoneOffset = date.getTimezoneOffset()\n  date.setSeconds(0, 0)\n  var millisecondsPartOfTimezoneOffset = date.getTime() % MILLISECONDS_IN_MINUTE\n\n  return baseTimezoneOffset * MILLISECONDS_IN_MINUTE + millisecondsPartOfTimezoneOffset\n}\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nvar ReactPropTypesSecret = require('./lib/ReactPropTypesSecret');\n\nfunction emptyFunction() {}\nfunction emptyFunctionWithReset() {}\nemptyFunctionWithReset.resetWarningCache = emptyFunction;\n\nmodule.exports = function() {\n  function shim(props, propName, componentName, location, propFullName, secret) {\n    if (secret === ReactPropTypesSecret) {\n      // It is still safe when called from React.\n      return;\n    }\n    var err = new Error(\n      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +\n      'Use PropTypes.checkPropTypes() to call them. ' +\n      'Read more at http://fb.me/use-check-prop-types'\n    );\n    err.name = 'Invariant Violation';\n    throw err;\n  };\n  shim.isRequired = shim;\n  function getShim() {\n    return shim;\n  };\n  // Important!\n  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.\n  var ReactPropTypes = {\n    array: shim,\n    bigint: shim,\n    bool: shim,\n    func: shim,\n    number: shim,\n    object: shim,\n    string: shim,\n    symbol: shim,\n\n    any: shim,\n    arrayOf: getShim,\n    element: shim,\n    elementType: shim,\n    instanceOf: getShim,\n    node: shim,\n    objectOf: getShim,\n    oneOf: getShim,\n    oneOfType: getShim,\n    shape: getShim,\n    exact: getShim,\n\n    checkPropTypes: emptyFunctionWithReset,\n    resetWarningCache: emptyFunction\n  };\n\n  ReactPropTypes.PropTypes = ReactPropTypes;\n\n  return ReactPropTypes;\n};\n","var addMinutes = require('../add_minutes/index.js')\n\n/**\n * @category Minute Helpers\n * @summary Subtract the specified number of minutes from the given date.\n *\n * @description\n * Subtract the specified number of minutes from the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of minutes to be subtracted\n * @returns {Date} the new date with the mintues subtracted\n *\n * @example\n * // Subtract 30 minutes from 10 July 2014 12:00:00:\n * var result = subMinutes(new Date(2014, 6, 10, 12, 0), 30)\n * //=> Thu Jul 10 2014 11:30:00\n */\nfunction subMinutes (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addMinutes(dirtyDate, -amount)\n}\n\nmodule.exports = subMinutes\n","var getTimezoneOffsetInMilliseconds = require('../_lib/getTimezoneOffsetInMilliseconds/index.js')\nvar isDate = require('../is_date/index.js')\n\nvar MILLISECONDS_IN_HOUR = 3600000\nvar MILLISECONDS_IN_MINUTE = 60000\nvar DEFAULT_ADDITIONAL_DIGITS = 2\n\nvar parseTokenDateTimeDelimeter = /[T ]/\nvar parseTokenPlainTime = /:/\n\n// year tokens\nvar parseTokenYY = /^(\\d{2})$/\nvar parseTokensYYY = [\n  /^([+-]\\d{2})$/, // 0 additional digits\n  /^([+-]\\d{3})$/, // 1 additional digit\n  /^([+-]\\d{4})$/ // 2 additional digits\n]\n\nvar parseTokenYYYY = /^(\\d{4})/\nvar parseTokensYYYYY = [\n  /^([+-]\\d{4})/, // 0 additional digits\n  /^([+-]\\d{5})/, // 1 additional digit\n  /^([+-]\\d{6})/ // 2 additional digits\n]\n\n// date tokens\nvar parseTokenMM = /^-(\\d{2})$/\nvar parseTokenDDD = /^-?(\\d{3})$/\nvar parseTokenMMDD = /^-?(\\d{2})-?(\\d{2})$/\nvar parseTokenWww = /^-?W(\\d{2})$/\nvar parseTokenWwwD = /^-?W(\\d{2})-?(\\d{1})$/\n\n// time tokens\nvar parseTokenHH = /^(\\d{2}([.,]\\d*)?)$/\nvar parseTokenHHMM = /^(\\d{2}):?(\\d{2}([.,]\\d*)?)$/\nvar parseTokenHHMMSS = /^(\\d{2}):?(\\d{2}):?(\\d{2}([.,]\\d*)?)$/\n\n// timezone tokens\nvar parseTokenTimezone = /([Z+-].*)$/\nvar parseTokenTimezoneZ = /^(Z)$/\nvar parseTokenTimezoneHH = /^([+-])(\\d{2})$/\nvar parseTokenTimezoneHHMM = /^([+-])(\\d{2}):?(\\d{2})$/\n\n/**\n * @category Common Helpers\n * @summary Convert the given argument to an instance of Date.\n *\n * @description\n * Convert the given argument to an instance of Date.\n *\n * If the argument is an instance of Date, the function returns its clone.\n *\n * If the argument is a number, it is treated as a timestamp.\n *\n * If an argument is a string, the function tries to parse it.\n * Function accepts complete ISO 8601 formats as well as partial implementations.\n * ISO 8601: http://en.wikipedia.org/wiki/ISO_8601\n *\n * If all above fails, the function passes the given argument to Date constructor.\n *\n * @param {Date|String|Number} argument - the value to convert\n * @param {Object} [options] - the object with options\n * @param {0 | 1 | 2} [options.additionalDigits=2] - the additional number of digits in the extended year format\n * @returns {Date} the parsed date in the local time zone\n *\n * @example\n * // Convert string '2014-02-11T11:30:30' to date:\n * var result = parse('2014-02-11T11:30:30')\n * //=> Tue Feb 11 2014 11:30:30\n *\n * @example\n * // Parse string '+02014101',\n * // if the additional number of digits in the extended year format is 1:\n * var result = parse('+02014101', {additionalDigits: 1})\n * //=> Fri Apr 11 2014 00:00:00\n */\nfunction parse (argument, dirtyOptions) {\n  if (isDate(argument)) {\n    // Prevent the date to lose the milliseconds when passed to new Date() in IE10\n    return new Date(argument.getTime())\n  } else if (typeof argument !== 'string') {\n    return new Date(argument)\n  }\n\n  var options = dirtyOptions || {}\n  var additionalDigits = options.additionalDigits\n  if (additionalDigits == null) {\n    additionalDigits = DEFAULT_ADDITIONAL_DIGITS\n  } else {\n    additionalDigits = Number(additionalDigits)\n  }\n\n  var dateStrings = splitDateString(argument)\n\n  var parseYearResult = parseYear(dateStrings.date, additionalDigits)\n  var year = parseYearResult.year\n  var restDateString = parseYearResult.restDateString\n\n  var date = parseDate(restDateString, year)\n\n  if (date) {\n    var timestamp = date.getTime()\n    var time = 0\n    var offset\n\n    if (dateStrings.time) {\n      time = parseTime(dateStrings.time)\n    }\n\n    if (dateStrings.timezone) {\n      offset = parseTimezone(dateStrings.timezone) * MILLISECONDS_IN_MINUTE\n    } else {\n      var fullTime = timestamp + time\n      var fullTimeDate = new Date(fullTime)\n\n      offset = getTimezoneOffsetInMilliseconds(fullTimeDate)\n\n      // Adjust time when it's coming from DST\n      var fullTimeDateNextDay = new Date(fullTime)\n      fullTimeDateNextDay.setDate(fullTimeDate.getDate() + 1)\n      var offsetDiff =\n        getTimezoneOffsetInMilliseconds(fullTimeDateNextDay) -\n        getTimezoneOffsetInMilliseconds(fullTimeDate)\n      if (offsetDiff > 0) {\n        offset += offsetDiff\n      }\n    }\n\n    return new Date(timestamp + time + offset)\n  } else {\n    return new Date(argument)\n  }\n}\n\nfunction splitDateString (dateString) {\n  var dateStrings = {}\n  var array = dateString.split(parseTokenDateTimeDelimeter)\n  var timeString\n\n  if (parseTokenPlainTime.test(array[0])) {\n    dateStrings.date = null\n    timeString = array[0]\n  } else {\n    dateStrings.date = array[0]\n    timeString = array[1]\n  }\n\n  if (timeString) {\n    var token = parseTokenTimezone.exec(timeString)\n    if (token) {\n      dateStrings.time = timeString.replace(token[1], '')\n      dateStrings.timezone = token[1]\n    } else {\n      dateStrings.time = timeString\n    }\n  }\n\n  return dateStrings\n}\n\nfunction parseYear (dateString, additionalDigits) {\n  var parseTokenYYY = parseTokensYYY[additionalDigits]\n  var parseTokenYYYYY = parseTokensYYYYY[additionalDigits]\n\n  var token\n\n  // YYYY or ±YYYYY\n  token = parseTokenYYYY.exec(dateString) || parseTokenYYYYY.exec(dateString)\n  if (token) {\n    var yearString = token[1]\n    return {\n      year: parseInt(yearString, 10),\n      restDateString: dateString.slice(yearString.length)\n    }\n  }\n\n  // YY or ±YYY\n  token = parseTokenYY.exec(dateString) || parseTokenYYY.exec(dateString)\n  if (token) {\n    var centuryString = token[1]\n    return {\n      year: parseInt(centuryString, 10) * 100,\n      restDateString: dateString.slice(centuryString.length)\n    }\n  }\n\n  // Invalid ISO-formatted year\n  return {\n    year: null\n  }\n}\n\nfunction parseDate (dateString, year) {\n  // Invalid ISO-formatted year\n  if (year === null) {\n    return null\n  }\n\n  var token\n  var date\n  var month\n  var week\n\n  // YYYY\n  if (dateString.length === 0) {\n    date = new Date(0)\n    date.setUTCFullYear(year)\n    return date\n  }\n\n  // YYYY-MM\n  token = parseTokenMM.exec(dateString)\n  if (token) {\n    date = new Date(0)\n    month = parseInt(token[1], 10) - 1\n    date.setUTCFullYear(year, month)\n    return date\n  }\n\n  // YYYY-DDD or YYYYDDD\n  token = parseTokenDDD.exec(dateString)\n  if (token) {\n    date = new Date(0)\n    var dayOfYear = parseInt(token[1], 10)\n    date.setUTCFullYear(year, 0, dayOfYear)\n    return date\n  }\n\n  // YYYY-MM-DD or YYYYMMDD\n  token = parseTokenMMDD.exec(dateString)\n  if (token) {\n    date = new Date(0)\n    month = parseInt(token[1], 10) - 1\n    var day = parseInt(token[2], 10)\n    date.setUTCFullYear(year, month, day)\n    return date\n  }\n\n  // YYYY-Www or YYYYWww\n  token = parseTokenWww.exec(dateString)\n  if (token) {\n    week = parseInt(token[1], 10) - 1\n    return dayOfISOYear(year, week)\n  }\n\n  // YYYY-Www-D or YYYYWwwD\n  token = parseTokenWwwD.exec(dateString)\n  if (token) {\n    week = parseInt(token[1], 10) - 1\n    var dayOfWeek = parseInt(token[2], 10) - 1\n    return dayOfISOYear(year, week, dayOfWeek)\n  }\n\n  // Invalid ISO-formatted date\n  return null\n}\n\nfunction parseTime (timeString) {\n  var token\n  var hours\n  var minutes\n\n  // hh\n  token = parseTokenHH.exec(timeString)\n  if (token) {\n    hours = parseFloat(token[1].replace(',', '.'))\n    return (hours % 24) * MILLISECONDS_IN_HOUR\n  }\n\n  // hh:mm or hhmm\n  token = parseTokenHHMM.exec(timeString)\n  if (token) {\n    hours = parseInt(token[1], 10)\n    minutes = parseFloat(token[2].replace(',', '.'))\n    return (hours % 24) * MILLISECONDS_IN_HOUR +\n      minutes * MILLISECONDS_IN_MINUTE\n  }\n\n  // hh:mm:ss or hhmmss\n  token = parseTokenHHMMSS.exec(timeString)\n  if (token) {\n    hours = parseInt(token[1], 10)\n    minutes = parseInt(token[2], 10)\n    var seconds = parseFloat(token[3].replace(',', '.'))\n    return (hours % 24) * MILLISECONDS_IN_HOUR +\n      minutes * MILLISECONDS_IN_MINUTE +\n      seconds * 1000\n  }\n\n  // Invalid ISO-formatted time\n  return null\n}\n\nfunction parseTimezone (timezoneString) {\n  var token\n  var absoluteOffset\n\n  // Z\n  token = parseTokenTimezoneZ.exec(timezoneString)\n  if (token) {\n    return 0\n  }\n\n  // ±hh\n  token = parseTokenTimezoneHH.exec(timezoneString)\n  if (token) {\n    absoluteOffset = parseInt(token[2], 10) * 60\n    return (token[1] === '+') ? -absoluteOffset : absoluteOffset\n  }\n\n  // ±hh:mm or ±hhmm\n  token = parseTokenTimezoneHHMM.exec(timezoneString)\n  if (token) {\n    absoluteOffset = parseInt(token[2], 10) * 60 + parseInt(token[3], 10)\n    return (token[1] === '+') ? -absoluteOffset : absoluteOffset\n  }\n\n  return 0\n}\n\nfunction dayOfISOYear (isoYear, week, day) {\n  week = week || 0\n  day = day || 0\n  var date = new Date(0)\n  date.setUTCFullYear(isoYear, 0, 4)\n  var fourthOfJanuaryDay = date.getUTCDay() || 7\n  var diff = week * 7 + day + 1 - fourthOfJanuaryDay\n  date.setUTCDate(date.getUTCDate() + diff)\n  return date\n}\n\nmodule.exports = parse\n","var parse = require('../parse/index.js')\n\n/**\n * @category Month Helpers\n * @summary Return the end of a month for the given date.\n *\n * @description\n * Return the end of a month for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @returns {Date} the end of a month\n *\n * @example\n * // The end of a month for 2 September 2014 11:55:00:\n * var result = endOfMonth(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 30 2014 23:59:59.999\n */\nfunction endOfMonth (dirtyDate) {\n  var date = parse(dirtyDate)\n  var month = date.getMonth()\n  date.setFullYear(date.getFullYear(), month + 1, 0)\n  date.setHours(23, 59, 59, 999)\n  return date\n}\n\nmodule.exports = endOfMonth\n","import { h, Component } from 'preact';\nimport { assign, mapActions, select } from '../util';\n\n/**\n * Wire a component up to the store. Passes state as props, re-renders on change.\n * @param {Function|Array|String} mapStateToProps  A function mapping of store state to prop values, or an array/CSV of properties to map.\n * @param {Function|Object} [actions] \t\t\t\tAction functions (pure state mappings), or a factory returning them. Every action function gets current state as the first parameter and any other params next\n * @returns {Component} ConnectedComponent\n * @example\n * const Foo = connect('foo,bar')( ({ foo, bar }) => <div /> )\n * @example\n * const actions = { someAction }\n * const Foo = connect('foo,bar', actions)( ({ foo, bar, someAction }) => <div /> )\n * @example\n * @connect( state => ({ foo: state.foo, bar: state.bar }) )\n * export class Foo { render({ foo, bar }) { } }\n */\nexport function connect(mapStateToProps, actions) {\n\tif (typeof mapStateToProps!='function') {\n\t\tmapStateToProps = select(mapStateToProps || {});\n\t}\n\treturn Child => {\n\t\tfunction Wrapper(props, context) {\n\t\t\tconst store = context.store;\n\t\t\tlet state = mapStateToProps(store ? store.getState() : {}, props);\n\t\t\tconst boundActions = actions ? mapActions(actions, store) : { store };\n\t\t\tlet update = () => {\n\t\t\t\tlet mapped = mapStateToProps(store ? store.getState() : {}, props);\n\t\t\t\tfor (let i in mapped) if (mapped[i]!==state[i]) {\n\t\t\t\t\tstate = mapped;\n\t\t\t\t\treturn this.setState({});\n\t\t\t\t}\n\t\t\t\tfor (let i in state) if (!(i in mapped)) {\n\t\t\t\t\tstate = mapped;\n\t\t\t\t\treturn this.setState({});\n\t\t\t\t}\n\t\t\t};\n\t\t\tthis.componentWillReceiveProps = p => {\n\t\t\t\tprops = p;\n\t\t\t\tupdate();\n\t\t\t};\n\t\t\tthis.componentDidMount = () => {\n\t\t\t\tstore.subscribe(update);\n\t\t\t};\n\t\t\tthis.componentWillUnmount = () => {\n\t\t\t\tstore.unsubscribe(update);\n\t\t\t};\n\t\t\tthis.render = props => h(Child, assign(assign(assign({}, boundActions), props), state));\n\t\t}\n\t\treturn (Wrapper.prototype = new Component()).constructor = Wrapper;\n\t};\n}\n\n\n/**\n * Provider exposes a store (passed as `props.store`) into context.\n *\n * Generally, an entire application is wrapped in a single `<Provider>` at the root.\n * @class\n * @extends Component\n * @param {Object} props\n * @param {Store} props.store\tA {Store} instance to expose via context.\n */\nexport function Provider(props) {\n\tthis.getChildContext = () => ({ store: props.store });\n}\nProvider.prototype.render = props => props.children && props.children[0] || props.children;\n","/**\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nif (process.env.NODE_ENV !== 'production') {\n  var ReactIs = require('react-is');\n\n  // By explicitly using `prop-types` you are opting into new development behavior.\n  // http://fb.me/prop-types-in-prod\n  var throwOnDirectAccess = true;\n  module.exports = require('./factoryWithTypeCheckers')(ReactIs.isElement, throwOnDirectAccess);\n} else {\n  // By explicitly using `prop-types` you are opting into new production behavior.\n  // http://fb.me/prop-types-in-prod\n  module.exports = require('./factoryWithThrowingShims')();\n}\n","module.exports = function unistoreDevTools(store) {\n\tvar extension = window.__REDUX_DEVTOOLS_EXTENSION__ || window.top.__REDUX_DEVTOOLS_EXTENSION__;\n\tvar ignoreState = false;\n\n\tif (!extension) {\n\t\tconsole.warn('Please install/enable Redux devtools extension');\n\t\tstore.devtools = null;\n\n\t\treturn store;\n\t}\n\n\tif (!store.devtools) {\n\t\tstore.devtools = extension.connect();\n\t\tstore.devtools.subscribe(function (message) {\n\t\t\tif (message.type === 'DISPATCH' && message.state) {\n\t\t\t\tignoreState = (message.payload.type === 'JUMP_TO_ACTION' || message.payload.type === 'JUMP_TO_STATE');\n\t\t\t\tstore.setState(JSON.parse(message.state), true);\n\t\t\t}\n\t\t});\n\t\tstore.devtools.init(store.getState());\n\t\tstore.subscribe(function (state, action) {\n\t\t\tvar actionName = action && action.name || 'setState';\n\n\t\t\tif (!ignoreState) {\n\t\t\t\tstore.devtools.send(actionName, state);\n\t\t\t} else {\n\t\t\t\tignoreState = false;\n\t\t\t}\n\t\t});\n\t}\n\n\treturn store;\n}\n","var addDays = require('../add_days/index.js')\n\n/**\n * @category Day Helpers\n * @summary Subtract the specified number of days from the given date.\n *\n * @description\n * Subtract the specified number of days from the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of days to be subtracted\n * @returns {Date} the new date with the days subtracted\n *\n * @example\n * // Subtract 10 days from 1 September 2014:\n * var result = subDays(new Date(2014, 8, 1), 10)\n * //=> Fri Aug 22 2014 00:00:00\n */\nfunction subDays (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addDays(dirtyDate, -amount)\n}\n\nmodule.exports = subDays\n","var startOfDay = require('../start_of_day/index.js')\n\n/**\n * @category Day Helpers\n * @summary Are the given dates in the same day?\n *\n * @description\n * Are the given dates in the same day?\n *\n * @param {Date|String|Number} dateLeft - the first date to check\n * @param {Date|String|Number} dateRight - the second date to check\n * @returns {Boolean} the dates are in the same day\n *\n * @example\n * // Are 4 September 06:00:00 and 4 September 18:00:00 in the same day?\n * var result = isSameDay(\n *   new Date(2014, 8, 4, 6, 0),\n *   new Date(2014, 8, 4, 18, 0)\n * )\n * //=> true\n */\nfunction isSameDay (dirtyDateLeft, dirtyDateRight) {\n  var dateLeftStartOfDay = startOfDay(dirtyDateLeft)\n  var dateRightStartOfDay = startOfDay(dirtyDateRight)\n\n  return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime()\n}\n\nmodule.exports = isSameDay\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 { 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\tcommitQueue = [],\n\t\trefQueue = [];\n\n\tif (component._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\tcomponent._parentDom,\n\t\t\tnewVNode,\n\t\t\toldVNode,\n\t\t\tcomponent._globalContext,\n\t\t\tcomponent._parentDom.namespaceURI,\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","/** 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 { 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 {string} namespace Current namespace of the DOM node (HTML, SVG, or MathML)\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\tnamespace,\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\tnamespace,\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 (\n\t\t\t\toldDom &&\n\t\t\t\ttypeof childVNode.type == 'string' &&\n\t\t\t\t// @ts-expect-error olDom should be present on a DOM node\n\t\t\t\t!parentDom.contains(oldDom)\n\t\t\t) {\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 = matchingIndex - skewedIndex;\n\t\t\t} else if (matchingIndex == skewedIndex + 1) {\n\t\t\t\tskew++;\n\t\t\t} else if (matchingIndex > skewedIndex) {\n\t\t\t\t// Our matched DOM-node is further in the list of children than\n\t\t\t\t// where it's at now.\n\n\t\t\t\t// When the remaining old children is bigger than the new-children\n\t\t\t\t// minus our skewed index we know we are dealing with a shrinking list\n\t\t\t\t// we have to increase our skew with the matchedIndex - the skewed index\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\t// If we have matched all the children just decrease the skew\n\t\t\t\t\tskew--;\n\t\t\t\t}\n\t\t\t} else if (matchingIndex < skewedIndex) {\n\t\t\t\t// When our new position is in front of our old position than we increase the skew\n\t\t\t\tskew++;\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// A logical clock to solve issues like https://github.com/preactjs/preact/issues/3927.\n// When the DOM performs an event it leaves micro-ticks in between bubbling up which means that\n// an event can trigger on a newly reated DOM-node while the event bubbles up.\n//\n// Originally inspired by Vue\n// (https://github.com/vuejs/core/blob/caeb8a68811a1b0f79/packages/runtime-dom/src/modules/events.ts#L90-L101),\n// but modified to use a logical clock instead of Date.now() in case event handlers get attached\n// and events get dispatched during the same millisecond.\n//\n// The clock is incremented after each new event dispatch. This allows 1 000 000 new events\n// per second for over 280 years before the value reaches Number.MAX_SAFE_INTEGER (2**53 - 1).\nlet eventClock = 0;\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 {string} namespace Whether or not this DOM node is an SVG node or not\n */\nexport function setProperty(dom, name, value, oldValue, namespace) {\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 = eventClock;\n\t\t\t\tdom.addEventListener(\n\t\t\t\t\tname,\n\t\t\t\t\tuseCapture ? eventProxyCapture : eventProxy,\n\t\t\t\t\tuseCapture\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tvalue._attached = oldValue._attached;\n\t\t\t}\n\t\t} else {\n\t\t\tdom.removeEventListener(\n\t\t\t\tname,\n\t\t\t\tuseCapture ? eventProxyCapture : eventProxy,\n\t\t\t\tuseCapture\n\t\t\t);\n\t\t}\n\t} else {\n\t\tif (namespace == 'http://www.w3.org/2000/svg') {\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 != 'popover' &&\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, name == 'popover' && value == true ? '' : value);\n\t\t} else {\n\t\t\tdom.removeAttribute(name);\n\t\t}\n\t}\n}\n\n/**\n * Create an event proxy function.\n * @param {boolean} useCapture Is the event handler for the capture phase.\n * @private\n */\nfunction createEventProxy(useCapture) {\n\t/**\n\t * Proxy an event to hooked event handlers\n\t * @param {PreactEvent} e The event object from the browser\n\t * @private\n\t */\n\treturn function (e) {\n\t\tif (this._listeners) {\n\t\t\tconst eventHandler = this._listeners[e.type + useCapture];\n\t\t\tif (e._dispatched == null) {\n\t\t\t\te._dispatched = eventClock++;\n\n\t\t\t\t// When `e._dispatched` is smaller than the time when the targeted event\n\t\t\t\t// handler was attached we know we have bubbled up to an element that was added\n\t\t\t\t// during patching the DOM.\n\t\t\t} else if (e._dispatched < eventHandler._attached) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\treturn eventHandler(options.event ? options.event(e) : e);\n\t\t}\n\t};\n}\n\nconst eventProxy = createEventProxy(false);\nconst eventProxyCapture = createEventProxy(true);\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 {string} namespace Current namespace of the DOM node (HTML, SVG, or MathML)\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\tnamespace,\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\t\t\tconst isClassComponent =\n\t\t\t\t'prototype' in newType && newType.prototype.render;\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 (isClassComponent) {\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 (isClassComponent && c._nextState == null) {\n\t\t\t\tc._nextState = c.state;\n\t\t\t}\n\n\t\t\tif (isClassComponent && 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\tisClassComponent &&\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 (isClassComponent && 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\tisClassComponent &&\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 (isClassComponent && 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 (isClassComponent) {\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 (isClassComponent && !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\tnamespace,\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\tnamespace,\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 {string} namespace Current namespace of the DOM node (HTML, SVG, or MathML)\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\tnamespace,\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 namespaces when descending through the tree.\n\tif (nodeType === 'svg') namespace = 'http://www.w3.org/2000/svg';\n\telse if (nodeType === 'math')\n\t\tnamespace = 'http://www.w3.org/1998/Math/MathML';\n\telse if (!namespace) namespace = 'http://www.w3.org/1999/xhtml';\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\tdom = document.createElementNS(\n\t\t\tnamespace,\n\t\t\tnodeType,\n\t\t\tnewProps.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\tif (\n\t\t\t\t\t(i == 'value' && 'defaultValue' in newProps) ||\n\t\t\t\t\t(i == 'checked' && 'defaultChecked' in newProps)\n\t\t\t\t) {\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tsetProperty(dom, i, null, value, namespace);\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], namespace);\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\tnodeType === 'foreignObject'\n\t\t\t\t\t? 'http://www.w3.org/1999/xhtml'\n\t\t\t\t\t: namespace,\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], namespace);\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], namespace);\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}\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._component = vnode._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","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.namespaceURI,\n\t\t!isHydrating && replaceNode\n\t\t\t? [replaceNode]\n\t\t\t: oldVNode\n\t\t\t\t? null\n\t\t\t\t: parentDom.firstChild\n\t\t\t\t\t? slice.call(parentDom.childNodes)\n\t\t\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\t? oldVNode._dom\n\t\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 { assign, slice } from './util';\nimport { createVNode } from './create-element';\n\n/**\n * Clones the given VNode, optionally adding attributes/props and replacing its\n * children.\n * @param {VNode} vnode The virtual DOM element to clone\n * @param {object} props Attributes/props to add when cloning\n * @param {Array<ComponentChildren>} rest Any additional arguments will be used\n * as replacement children.\n * @returns {VNode}\n */\nexport function cloneElement(vnode, props, children) {\n\tlet normalizedProps = assign({}, vnode.props),\n\t\tkey,\n\t\tref,\n\t\ti;\n\n\tlet defaultProps;\n\n\tif (vnode.type && vnode.type.defaultProps) {\n\t\tdefaultProps = vnode.type.defaultProps;\n\t}\n\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 if (props[i] === undefined && defaultProps !== undefined) {\n\t\t\tnormalizedProps[i] = defaultProps[i];\n\t\t} else {\n\t\t\tnormalizedProps[i] = props[i];\n\t\t}\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\treturn createVNode(\n\t\tvnode.type,\n\t\tnormalizedProps,\n\t\tkey || vnode.key,\n\t\tref || vnode.ref,\n\t\tnull\n\t);\n}\n","import { enqueueRender } from './component';\n\nexport let i = 0;\n\nexport function createContext(defaultValue, contextId) {\n\tcontextId = '__cC' + i++;\n\n\tconst context = {\n\t\t_id: contextId,\n\t\t_defaultValue: defaultValue,\n\t\t/** @type {FunctionComponent} */\n\t\tConsumer(props, contextValue) {\n\t\t\t// return props.children(\n\t\t\t// \tcontext[contextId] ? context[contextId].props.value : defaultValue\n\t\t\t// );\n\t\t\treturn props.children(contextValue);\n\t\t},\n\t\t/** @type {FunctionComponent} */\n\t\tProvider(props) {\n\t\t\tif (!this.getChildContext) {\n\t\t\t\t/** @type {Component[] | null} */\n\t\t\t\tlet subs = [];\n\t\t\t\tlet ctx = {};\n\t\t\t\tctx[contextId] = this;\n\n\t\t\t\tthis.getChildContext = () => ctx;\n\n\t\t\t\tthis.componentWillUnmount = () => {\n\t\t\t\t\tsubs = null;\n\t\t\t\t};\n\n\t\t\t\tthis.shouldComponentUpdate = function (_props) {\n\t\t\t\t\tif (this.props.value !== _props.value) {\n\t\t\t\t\t\tsubs.some(c => {\n\t\t\t\t\t\t\tc._force = true;\n\t\t\t\t\t\t\tenqueueRender(c);\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\tthis.sub = c => {\n\t\t\t\t\tsubs.push(c);\n\t\t\t\t\tlet old = c.componentWillUnmount;\n\t\t\t\t\tc.componentWillUnmount = () => {\n\t\t\t\t\t\tif (subs) {\n\t\t\t\t\t\t\tsubs.splice(subs.indexOf(c), 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (old) old.call(c);\n\t\t\t\t\t};\n\t\t\t\t};\n\t\t\t}\n\n\t\t\treturn props.children;\n\t\t}\n\t};\n\n\t// Devtools needs access to the context object when it\n\t// encounters a Provider. This is necessary to support\n\t// setting `displayName` on the context object instead\n\t// of on the component itself. See:\n\t// https://reactjs.org/docs/context.html#contextdisplayname\n\n\treturn (context.Provider._contextRef = context.Consumer.contextType =\n\t\tcontext);\n}\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","/**\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","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\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._pendingArgs = hookItem._nextValue = 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\thookItem._pendingArgs = undefined;\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({});\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._value = factory();\n\t\tstate._args = args;\n\t\tstate._factory = factory;\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","/**\n * Assign properties from `props` to `obj`\n * @template O, P The obj and props types\n * @param {O} obj The object to copy properties to\n * @param {P} props The object to copy properties from\n * @returns {O & P}\n */\nexport function assign(obj, props) {\n\tfor (let i in props) obj[i] = props[i];\n\treturn /** @type {O & P} */ (obj);\n}\n\n/**\n * Check if two objects have a different shape\n * @param {object} a\n * @param {object} b\n * @returns {boolean}\n */\nexport function shallowDiffers(a, b) {\n\tfor (let i in a) if (i !== '__source' && !(i in b)) return true;\n\tfor (let i in b) if (i !== '__source' && a[i] !== b[i]) return true;\n\treturn false;\n}\n\n/**\n * Check if two values are the same value\n * @param {*} x\n * @param {*} y\n * @returns {boolean}\n */\nexport function is(x, y) {\n\treturn (x === y && (x !== 0 || 1 / x === 1 / y)) || (x !== x && y !== y);\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 { createElement } from 'preact';\nimport { shallowDiffers } from './util';\n\n/**\n * Memoize a component, so that it only updates when the props actually have\n * changed. This was previously known as `React.pure`.\n * @param {import('./internal').FunctionComponent} c functional component\n * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function\n * @returns {import('./internal').FunctionComponent}\n */\nexport function memo(c, comparer) {\n\tfunction shouldUpdate(nextProps) {\n\t\tlet ref = this.props.ref;\n\t\tlet updateRef = ref == nextProps.ref;\n\t\tif (!updateRef && ref) {\n\t\t\tref.call ? ref(null) : (ref.current = null);\n\t\t}\n\n\t\tif (!comparer) {\n\t\t\treturn shallowDiffers(this.props, nextProps);\n\t\t}\n\n\t\treturn !comparer(this.props, nextProps) || !updateRef;\n\t}\n\n\tfunction Memoed(props) {\n\t\tthis.shouldComponentUpdate = shouldUpdate;\n\t\treturn createElement(c, props);\n\t}\n\tMemoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';\n\tMemoed.prototype.isReactComponent = true;\n\tMemoed._forwarded = true;\n\treturn Memoed;\n}\n","import { options } from 'preact';\nimport { assign } from './util';\n\nlet oldDiffHook = options._diff;\noptions._diff = vnode => {\n\tif (vnode.type && vnode.type._forwarded && vnode.ref) {\n\t\tvnode.props.ref = vnode.ref;\n\t\tvnode.ref = null;\n\t}\n\tif (oldDiffHook) oldDiffHook(vnode);\n};\n\nexport const REACT_FORWARD_SYMBOL =\n\t(typeof Symbol != 'undefined' &&\n\t\tSymbol.for &&\n\t\tSymbol.for('react.forward_ref')) ||\n\t0xf47;\n\n/**\n * Pass ref down to a child. This is mainly used in libraries with HOCs that\n * wrap components. Using `forwardRef` there is an easy way to get a reference\n * of the wrapped component instead of one of the wrapper itself.\n * @param {import('./index').ForwardFn} fn\n * @returns {import('./internal').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 { 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","import { createElement, render } from 'preact';\n\n/**\n * @param {import('../../src/index').RenderableProps<{ context: any }>} props\n */\nfunction ContextProvider(props) {\n\tthis.getChildContext = () => props.context;\n\treturn props.children;\n}\n\n/**\n * Portal component\n * @this {import('./internal').Component}\n * @param {object | null | undefined} props\n *\n * TODO: use createRoot() instead of fake root\n */\nfunction Portal(props) {\n\tconst _this = this;\n\tlet container = props._container;\n\n\t_this.componentWillUnmount = function () {\n\t\trender(null, _this._temp);\n\t\t_this._temp = null;\n\t\t_this._container = null;\n\t};\n\n\t// When we change container we should clear our old container and\n\t// indicate a new mount.\n\tif (_this._container && _this._container !== container) {\n\t\t_this.componentWillUnmount();\n\t}\n\n\tif (!_this._temp) {\n\t\t_this._container = container;\n\n\t\t// Create a fake DOM parent node that manages a subset of `container`'s children:\n\t\t_this._temp = {\n\t\t\tnodeType: 1,\n\t\t\tparentNode: container,\n\t\t\tchildNodes: [],\n\t\t\tcontains: () => true,\n\t\t\tappendChild(child) {\n\t\t\t\tthis.childNodes.push(child);\n\t\t\t\t_this._container.appendChild(child);\n\t\t\t},\n\t\t\tinsertBefore(child, before) {\n\t\t\t\tthis.childNodes.push(child);\n\t\t\t\t_this._container.appendChild(child);\n\t\t\t},\n\t\t\tremoveChild(child) {\n\t\t\t\tthis.childNodes.splice(this.childNodes.indexOf(child) >>> 1, 1);\n\t\t\t\t_this._container.removeChild(child);\n\t\t\t}\n\t\t};\n\t}\n\n\t// Render our wrapping element into temp.\n\trender(\n\t\tcreateElement(ContextProvider, { context: _this.context }, props._vnode),\n\t\t_this._temp\n\t);\n}\n\n/**\n * Create a `Portal` to continue rendering the vnode tree at a different DOM node\n * @param {import('./internal').VNode} vnode The vnode to render\n * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.\n */\nexport function createPortal(vnode, container) {\n\tconst el = createElement(Portal, { _vnode: vnode, _container: container });\n\tel.containerInfo = container;\n\treturn el;\n}\n","import {\n\trender as preactRender,\n\thydrate as preactHydrate,\n\toptions,\n\ttoChildArray,\n\tComponent\n} from 'preact';\nimport {\n\tuseCallback,\n\tuseContext,\n\tuseDebugValue,\n\tuseEffect,\n\tuseId,\n\tuseImperativeHandle,\n\tuseLayoutEffect,\n\tuseMemo,\n\tuseReducer,\n\tuseRef,\n\tuseState\n} from 'preact/hooks';\nimport {\n\tuseDeferredValue,\n\tuseInsertionEffect,\n\tuseSyncExternalStore,\n\tuseTransition\n} from './index';\n\nexport const REACT_ELEMENT_TYPE =\n\t(typeof Symbol != 'undefined' && Symbol.for && Symbol.for('react.element')) ||\n\t0xeac7;\n\nconst CAMEL_PROPS =\n\t/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;\nconst ON_ANI = /^on(Ani|Tra|Tou|BeforeInp|Compo)/;\nconst CAMEL_REPLACE = /[A-Z0-9]/g;\n\nconst IS_DOM = typeof document !== 'undefined';\n\n// Input types for which onchange should not be converted to oninput.\n// type=\"file|checkbox|radio\", plus \"range\" in IE11.\n// (IE11 doesn't support Symbol, which we use here to turn `rad` into `ra` which matches \"range\")\nconst onChangeInputType = type =>\n\t(typeof Symbol != 'undefined' && typeof Symbol() == 'symbol'\n\t\t? /fil|che|rad/\n\t\t: /fil|che|ra/\n\t).test(type);\n\n// Some libraries like `react-virtualized` explicitly check for this.\nComponent.prototype.isReactComponent = {};\n\n// `UNSAFE_*` lifecycle hooks\n// Preact only ever invokes the unprefixed methods.\n// Here we provide a base \"fallback\" implementation that calls any defined UNSAFE_ prefixed method.\n// - If a component defines its own `componentDidMount()` (including via defineProperty), use that.\n// - If a component defines `UNSAFE_componentDidMount()`, `componentDidMount` is the alias getter/setter.\n// - If anything assigns to an `UNSAFE_*` property, the assignment is forwarded to the unprefixed property.\n// See https://github.com/preactjs/preact/issues/1941\n[\n\t'componentWillMount',\n\t'componentWillReceiveProps',\n\t'componentWillUpdate'\n].forEach(key => {\n\tObject.defineProperty(Component.prototype, key, {\n\t\tconfigurable: true,\n\t\tget() {\n\t\t\treturn this['UNSAFE_' + key];\n\t\t},\n\t\tset(v) {\n\t\t\tObject.defineProperty(this, key, {\n\t\t\t\tconfigurable: true,\n\t\t\t\twritable: true,\n\t\t\t\tvalue: v\n\t\t\t});\n\t\t}\n\t});\n});\n\n/**\n * Proxy render() since React returns a Component reference.\n * @param {import('./internal').VNode} vnode VNode tree to render\n * @param {import('./internal').PreactElement} parent DOM node to render vnode tree into\n * @param {() => void} [callback] Optional callback that will be called after rendering\n * @returns {import('./internal').Component | null} The root component reference or null\n */\nexport function render(vnode, parent, callback) {\n\t// React destroys any existing DOM nodes, see #1727\n\t// ...but only on the first render, see #1828\n\tif (parent._children == null) {\n\t\tparent.textContent = '';\n\t}\n\n\tpreactRender(vnode, parent);\n\tif (typeof callback == 'function') callback();\n\n\treturn vnode ? vnode._component : null;\n}\n\nexport function hydrate(vnode, parent, callback) {\n\tpreactHydrate(vnode, parent);\n\tif (typeof callback == 'function') callback();\n\n\treturn vnode ? vnode._component : null;\n}\n\nlet oldEventHook = options.event;\noptions.event = e => {\n\tif (oldEventHook) e = oldEventHook(e);\n\n\te.persist = empty;\n\te.isPropagationStopped = isPropagationStopped;\n\te.isDefaultPrevented = isDefaultPrevented;\n\treturn (e.nativeEvent = e);\n};\n\nfunction empty() {}\n\nfunction isPropagationStopped() {\n\treturn this.cancelBubble;\n}\n\nfunction isDefaultPrevented() {\n\treturn this.defaultPrevented;\n}\n\nconst classNameDescriptorNonEnumberable = {\n\tenumerable: false,\n\tconfigurable: true,\n\tget() {\n\t\treturn this.class;\n\t}\n};\n\nfunction handleDomVNode(vnode) {\n\tlet props = vnode.props,\n\t\ttype = vnode.type,\n\t\tnormalizedProps = {};\n\n\tfor (let i in props) {\n\t\tlet value = props[i];\n\n\t\tif (\n\t\t\t(i === 'value' && 'defaultValue' in props && value == null) ||\n\t\t\t// Emulate React's behavior of not rendering the contents of noscript tags on the client.\n\t\t\t(IS_DOM && i === 'children' && type === 'noscript') ||\n\t\t\ti === 'class' ||\n\t\t\ti === 'className'\n\t\t) {\n\t\t\t// Skip applying value if it is null/undefined and we already set\n\t\t\t// a default value\n\t\t\tcontinue;\n\t\t}\n\n\t\tlet lowerCased = i.toLowerCase();\n\t\tif (i === 'defaultValue' && 'value' in props && props.value == null) {\n\t\t\t// `defaultValue` is treated as a fallback `value` when a value prop is present but null/undefined.\n\t\t\t// `defaultValue` for Elements with no value prop is the same as the DOM defaultValue property.\n\t\t\ti = 'value';\n\t\t} else if (i === 'download' && value === true) {\n\t\t\t// Calling `setAttribute` with a truthy value will lead to it being\n\t\t\t// passed as a stringified value, e.g. `download=\"true\"`. React\n\t\t\t// converts it to an empty string instead, otherwise the attribute\n\t\t\t// value will be used as the file name and the file will be called\n\t\t\t// \"true\" upon downloading it.\n\t\t\tvalue = '';\n\t\t} else if (lowerCased === 'translate' && value === 'no') {\n\t\t\tvalue = false;\n\t\t} else if (lowerCased === 'ondoubleclick') {\n\t\t\ti = 'ondblclick';\n\t\t} else if (\n\t\t\tlowerCased === 'onchange' &&\n\t\t\t(type === 'input' || type === 'textarea') &&\n\t\t\t!onChangeInputType(props.type)\n\t\t) {\n\t\t\tlowerCased = i = 'oninput';\n\t\t} else if (lowerCased === 'onfocus') {\n\t\t\ti = 'onfocusin';\n\t\t} else if (lowerCased === 'onblur') {\n\t\t\ti = 'onfocusout';\n\t\t} else if (ON_ANI.test(i)) {\n\t\t\ti = lowerCased;\n\t\t} else if (type.indexOf('-') === -1 && CAMEL_PROPS.test(i)) {\n\t\t\ti = i.replace(CAMEL_REPLACE, '-$&').toLowerCase();\n\t\t} else if (value === null) {\n\t\t\tvalue = undefined;\n\t\t}\n\n\t\t// Add support for onInput and onChange, see #3561\n\t\t// if we have an oninput prop already change it to oninputCapture\n\t\tif (lowerCased === 'oninput') {\n\t\t\ti = lowerCased;\n\t\t\tif (normalizedProps[i]) {\n\t\t\t\ti = 'oninputCapture';\n\t\t\t}\n\t\t}\n\n\t\tnormalizedProps[i] = value;\n\t}\n\n\t// Add support for array select values: <select multiple value={[]} />\n\tif (\n\t\ttype == 'select' &&\n\t\tnormalizedProps.multiple &&\n\t\tArray.isArray(normalizedProps.value)\n\t) {\n\t\t// forEach() always returns undefined, which we abuse here to unset the value prop.\n\t\tnormalizedProps.value = toChildArray(props.children).forEach(child => {\n\t\t\tchild.props.selected =\n\t\t\t\tnormalizedProps.value.indexOf(child.props.value) != -1;\n\t\t});\n\t}\n\n\t// Adding support for defaultValue in select tag\n\tif (type == 'select' && normalizedProps.defaultValue != null) {\n\t\tnormalizedProps.value = toChildArray(props.children).forEach(child => {\n\t\t\tif (normalizedProps.multiple) {\n\t\t\t\tchild.props.selected =\n\t\t\t\t\tnormalizedProps.defaultValue.indexOf(child.props.value) != -1;\n\t\t\t} else {\n\t\t\t\tchild.props.selected =\n\t\t\t\t\tnormalizedProps.defaultValue == child.props.value;\n\t\t\t}\n\t\t});\n\t}\n\n\tif (props.class && !props.className) {\n\t\tnormalizedProps.class = props.class;\n\t\tObject.defineProperty(\n\t\t\tnormalizedProps,\n\t\t\t'className',\n\t\t\tclassNameDescriptorNonEnumberable\n\t\t);\n\t} else if (props.className && !props.class) {\n\t\tnormalizedProps.class = normalizedProps.className = props.className;\n\t} else if (props.class && props.className) {\n\t\tnormalizedProps.class = normalizedProps.className = props.className;\n\t}\n\n\tvnode.props = normalizedProps;\n}\n\nlet oldVNodeHook = options.vnode;\noptions.vnode = vnode => {\n\t// only normalize props on Element nodes\n\tif (typeof vnode.type === 'string') {\n\t\thandleDomVNode(vnode);\n\t}\n\n\tvnode.$$typeof = REACT_ELEMENT_TYPE;\n\n\tif (oldVNodeHook) oldVNodeHook(vnode);\n};\n\n// Only needed for react-relay\nlet currentComponent;\nconst oldBeforeRender = options._render;\noptions._render = function (vnode) {\n\tif (oldBeforeRender) {\n\t\toldBeforeRender(vnode);\n\t}\n\tcurrentComponent = vnode._component;\n};\n\nconst oldDiffed = options.diffed;\n/** @type {(vnode: import('./internal').VNode) => void} */\noptions.diffed = function (vnode) {\n\tif (oldDiffed) {\n\t\toldDiffed(vnode);\n\t}\n\n\tconst props = vnode.props;\n\tconst dom = vnode._dom;\n\n\tif (\n\t\tdom != null &&\n\t\tvnode.type === 'textarea' &&\n\t\t'value' in props &&\n\t\tprops.value !== dom.value\n\t) {\n\t\tdom.value = props.value == null ? '' : props.value;\n\t}\n\n\tcurrentComponent = null;\n};\n\n// This is a very very private internal function for React it\n// is used to sort-of do runtime dependency injection.\nexport const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {\n\tReactCurrentDispatcher: {\n\t\tcurrent: {\n\t\t\treadContext(context) {\n\t\t\t\treturn currentComponent._globalContext[context._id].props.value;\n\t\t\t},\n\t\t\tuseCallback,\n\t\t\tuseContext,\n\t\t\tuseDebugValue,\n\t\t\tuseDeferredValue,\n\t\t\tuseEffect,\n\t\t\tuseId,\n\t\t\tuseImperativeHandle,\n\t\t\tuseInsertionEffect,\n\t\t\tuseLayoutEffect,\n\t\t\tuseMemo,\n\t\t\t// useMutableSource, // experimental-only and replaced by uSES, likely not worth supporting\n\t\t\tuseReducer,\n\t\t\tuseRef,\n\t\t\tuseState,\n\t\t\tuseSyncExternalStore,\n\t\t\tuseTransition\n\t\t}\n\t}\n};\n","import {\n\tcreateElement,\n\trender as preactRender,\n\tcloneElement as preactCloneElement,\n\tcreateRef,\n\tComponent,\n\tcreateContext,\n\tFragment\n} from 'preact';\nimport {\n\tuseState,\n\tuseId,\n\tuseReducer,\n\tuseEffect,\n\tuseLayoutEffect,\n\tuseRef,\n\tuseImperativeHandle,\n\tuseMemo,\n\tuseCallback,\n\tuseContext,\n\tuseDebugValue\n} from 'preact/hooks';\nimport { PureComponent } from './PureComponent';\nimport { memo } from './memo';\nimport { forwardRef } from './forwardRef';\nimport { Children } from './Children';\nimport { Suspense, lazy } from './suspense';\nimport { SuspenseList } from './suspense-list';\nimport { createPortal } from './portals';\nimport { is } from './util';\nimport {\n\thydrate,\n\trender,\n\tREACT_ELEMENT_TYPE,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\n} from './render';\n\nconst version = '17.0.2'; // trick libraries to think we are react\n\n/**\n * Legacy version of createElement.\n * @param {import('./internal').VNode[\"type\"]} type The node name or Component constructor\n */\nfunction createFactory(type) {\n\treturn createElement.bind(null, type);\n}\n\n/**\n * Check if the passed element is a valid (p)react node.\n * @param {*} element The element to check\n * @returns {boolean}\n */\nfunction isValidElement(element) {\n\treturn !!element && element.$$typeof === REACT_ELEMENT_TYPE;\n}\n\n/**\n * Check if the passed element is a Fragment node.\n * @param {*} element The element to check\n * @returns {boolean}\n */\nfunction isFragment(element) {\n\treturn isValidElement(element) && element.type === Fragment;\n}\n\n/**\n * Check if the passed element is a Memo node.\n * @param {*} element The element to check\n * @returns {boolean}\n */\nfunction isMemo(element) {\n\treturn (\n\t\t!!element &&\n\t\t!!element.displayName &&\n\t\t(typeof element.displayName === 'string' ||\n\t\t\telement.displayName instanceof String) &&\n\t\telement.displayName.startsWith('Memo(')\n\t);\n}\n\n/**\n * Wrap `cloneElement` to abort if the passed element is not a valid element and apply\n * all vnode normalizations.\n * @param {import('./internal').VNode} element The vnode to clone\n * @param {object} props Props to add when cloning\n * @param {Array<import('./internal').ComponentChildren>} rest Optional component children\n */\nfunction cloneElement(element) {\n\tif (!isValidElement(element)) return element;\n\treturn preactCloneElement.apply(null, arguments);\n}\n\n/**\n * Remove a component tree from the DOM, including state and event handlers.\n * @param {import('./internal').PreactElement} container\n * @returns {boolean}\n */\nfunction unmountComponentAtNode(container) {\n\tif (container._children) {\n\t\tpreactRender(null, container);\n\t\treturn true;\n\t}\n\treturn false;\n}\n\n/**\n * Get the matching DOM node for a component\n * @param {import('./internal').Component} component\n * @returns {import('./internal').PreactElement | null}\n */\nfunction findDOMNode(component) {\n\treturn (\n\t\t(component &&\n\t\t\t(component.base || (component.nodeType === 1 && component))) ||\n\t\tnull\n\t);\n}\n\n/**\n * Deprecated way to control batched rendering inside the reconciler, but we\n * already schedule in batches inside our rendering code\n * @template Arg\n * @param {(arg: Arg) => void} callback function that triggers the updated\n * @param {Arg} [arg] Optional argument that can be passed to the callback\n */\n// eslint-disable-next-line camelcase\nconst unstable_batchedUpdates = (callback, arg) => callback(arg);\n\n/**\n * In React, `flushSync` flushes the entire tree and forces a rerender. It's\n * implmented here as a no-op.\n * @template Arg\n * @template Result\n * @param {(arg: Arg) => Result} callback function that runs before the flush\n * @param {Arg} [arg] Optional argument that can be passed to the callback\n * @returns\n */\nconst flushSync = (callback, arg) => callback(arg);\n\n/**\n * Strict Mode is not implemented in Preact, so we provide a stand-in for it\n * that just renders its children without imposing any restrictions.\n */\nconst StrictMode = Fragment;\n\nexport function startTransition(cb) {\n\tcb();\n}\n\nexport function useDeferredValue(val) {\n\treturn val;\n}\n\nexport function useTransition() {\n\treturn [false, startTransition];\n}\n\n// TODO: in theory this should be done after a VNode is diffed as we want to insert\n// styles/... before it attaches\nexport const useInsertionEffect = useLayoutEffect;\n\n// compat to react-is\nexport const isElement = isValidElement;\n\n/**\n * This is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84\n * on a high level this cuts out the warnings, ... and attempts a smaller implementation\n * @typedef {{ _value: any; _getSnapshot: () => any }} Store\n */\nexport function useSyncExternalStore(subscribe, getSnapshot) {\n\tconst value = getSnapshot();\n\n\t/**\n\t * @typedef {{ _instance: Store }} StoreRef\n\t * @type {[StoreRef, (store: StoreRef) => void]}\n\t */\n\tconst [{ _instance }, forceUpdate] = useState({\n\t\t_instance: { _value: value, _getSnapshot: getSnapshot }\n\t});\n\n\tuseLayoutEffect(() => {\n\t\t_instance._value = value;\n\t\t_instance._getSnapshot = getSnapshot;\n\n\t\tif (didSnapshotChange(_instance)) {\n\t\t\tforceUpdate({ _instance });\n\t\t}\n\t}, [subscribe, value, getSnapshot]);\n\n\tuseEffect(() => {\n\t\tif (didSnapshotChange(_instance)) {\n\t\t\tforceUpdate({ _instance });\n\t\t}\n\n\t\treturn subscribe(() => {\n\t\t\tif (didSnapshotChange(_instance)) {\n\t\t\t\tforceUpdate({ _instance });\n\t\t\t}\n\t\t});\n\t}, [subscribe]);\n\n\treturn value;\n}\n\n/** @type {(inst: Store) => boolean} */\nfunction didSnapshotChange(inst) {\n\tconst latestGetSnapshot = inst._getSnapshot;\n\tconst prevValue = inst._value;\n\ttry {\n\t\tconst nextValue = latestGetSnapshot();\n\t\treturn !is(prevValue, nextValue);\n\t} catch (error) {\n\t\treturn true;\n\t}\n}\n\nexport * from 'preact/hooks';\nexport {\n\tversion,\n\tChildren,\n\trender,\n\thydrate,\n\tunmountComponentAtNode,\n\tcreatePortal,\n\tcreateElement,\n\tcreateContext,\n\tcreateFactory,\n\tcloneElement,\n\tcreateRef,\n\tFragment,\n\tisValidElement,\n\tisFragment,\n\tisMemo,\n\tfindDOMNode,\n\tComponent,\n\tPureComponent,\n\tmemo,\n\tforwardRef,\n\tflushSync,\n\t// eslint-disable-next-line camelcase\n\tunstable_batchedUpdates,\n\tStrictMode,\n\tSuspense,\n\tSuspenseList,\n\tlazy,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\n};\n\n// React copies the named exports to the default one.\nexport default {\n\tuseState,\n\tuseId,\n\tuseReducer,\n\tuseEffect,\n\tuseLayoutEffect,\n\tuseInsertionEffect,\n\tuseTransition,\n\tuseDeferredValue,\n\tuseSyncExternalStore,\n\tstartTransition,\n\tuseRef,\n\tuseImperativeHandle,\n\tuseMemo,\n\tuseCallback,\n\tuseContext,\n\tuseDebugValue,\n\tversion,\n\tChildren,\n\trender,\n\thydrate,\n\tunmountComponentAtNode,\n\tcreatePortal,\n\tcreateElement,\n\tcreateContext,\n\tcreateFactory,\n\tcloneElement,\n\tcreateRef,\n\tFragment,\n\tisValidElement,\n\tisElement,\n\tisFragment,\n\tisMemo,\n\tfindDOMNode,\n\tComponent,\n\tPureComponent,\n\tmemo,\n\tforwardRef,\n\tflushSync,\n\tunstable_batchedUpdates,\n\tStrictMode,\n\tSuspense,\n\tSuspenseList,\n\tlazy,\n\t__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED\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","var parse = require('../parse/index.js')\n\n/**\n * @category Day Helpers\n * @summary Return the end of a day for the given date.\n *\n * @description\n * Return the end of a day for the given date.\n * The result will be in the local timezone.\n *\n * @param {Date|String|Number} date - the original date\n * @returns {Date} the end of a day\n *\n * @example\n * // The end of a day for 2 September 2014 11:55:00:\n * var result = endOfDay(new Date(2014, 8, 2, 11, 55, 0))\n * //=> Tue Sep 02 2014 23:59:59.999\n */\nfunction endOfDay (dirtyDate) {\n  var date = parse(dirtyDate)\n  date.setHours(23, 59, 59, 999)\n  return date\n}\n\nmodule.exports = endOfDay\n","var addMilliseconds = require('../add_milliseconds/index.js')\n\nvar MILLISECONDS_IN_HOUR = 3600000\n\n/**\n * @category Hour Helpers\n * @summary Add the specified number of hours to the given date.\n *\n * @description\n * Add the specified number of hours to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of hours to be added\n * @returns {Date} the new date with the hours added\n *\n * @example\n * // Add 2 hours to 10 July 2014 23:00:00:\n * var result = addHours(new Date(2014, 6, 10, 23, 0), 2)\n * //=> Fri Jul 11 2014 01:00:00\n */\nfunction addHours (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addMilliseconds(dirtyDate, amount * MILLISECONDS_IN_HOUR)\n}\n\nmodule.exports = addHours\n","var addMilliseconds = require('../add_milliseconds/index.js')\n\n/**\n * @category Second Helpers\n * @summary Add the specified number of seconds to the given date.\n *\n * @description\n * Add the specified number of seconds to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of seconds to be added\n * @returns {Date} the new date with the seconds added\n *\n * @example\n * // Add 30 seconds to 10 July 2014 12:45:00:\n * var result = addSeconds(new Date(2014, 6, 10, 12, 45, 0), 30)\n * //=> Thu Jul 10 2014 12:45:30\n */\nfunction addSeconds (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  return addMilliseconds(dirtyDate, amount * 1000)\n}\n\nmodule.exports = addSeconds\n","var parse = require('../parse/index.js')\n\n/**\n * @category Common Helpers\n * @summary Is the first date before the second one?\n *\n * @description\n * Is the first date before the second one?\n *\n * @param {Date|String|Number} date - the date that should be before the other one to return true\n * @param {Date|String|Number} dateToCompare - the date to compare with\n * @returns {Boolean} the first date is before the second date\n *\n * @example\n * // Is 10 July 1989 before 11 February 1987?\n * var result = isBefore(new Date(1989, 6, 10), new Date(1987, 1, 11))\n * //=> false\n */\nfunction isBefore (dirtyDate, dirtyDateToCompare) {\n  var date = parse(dirtyDate)\n  var dateToCompare = parse(dirtyDateToCompare)\n  return date.getTime() < dateToCompare.getTime()\n}\n\nmodule.exports = isBefore\n","var addDays = require('../add_days/index.js')\n\n/**\n * @category Week Helpers\n * @summary Add the specified number of weeks to the given date.\n *\n * @description\n * Add the specified number of week to the given date.\n *\n * @param {Date|String|Number} date - the date to be changed\n * @param {Number} amount - the amount of weeks to be added\n * @returns {Date} the new date with the weeks added\n *\n * @example\n * // Add 4 weeks to 1 September 2014:\n * var result = addWeeks(new Date(2014, 8, 1), 4)\n * //=> Mon Sep 29 2014 00:00:00\n */\nfunction addWeeks (dirtyDate, dirtyAmount) {\n  var amount = Number(dirtyAmount)\n  var days = amount * 7\n  return addDays(dirtyDate, days)\n}\n\nmodule.exports = addWeeks\n"],"sourceRoot":""}