{"version":3,"file":"coopse.script.9567.82fc4075.chunk.js","mappings":"mHAiB4BA,EAAQ,QAAoC,EACxE,IAAIC,EAAY,EAAQ,MAExBC,OAAOC,eAAeH,EAAS,KAA/B,CAA2CI,YAAY,EAAMC,IAAK,WAAc,OAAOJ,EAAUK,MAAQ,G,uBCJzGJ,OAAOC,eAAeH,EAAS,aAAc,CAAEO,OAAO,IACtDP,EAAQQ,iBAAmBR,EAAQS,kBAAoBT,EAAQM,YAAS,EACxE,MAAMI,EAAQ,EAAQ,OAKtB,SAASD,EAAkBE,EAAMC,EAAU,CAAC,GACxC,MAAO,CACHC,KAAM,sBACNC,wBAAyB,CACrBC,OAAQC,KAAKC,UAAUN,EAAMO,EAAoBN,EAAQO,QAGrE,CARAnB,EAAQM,OAHR,SAAgBc,GACZ,OAAOV,EAAMW,cAAc,SAAUnB,OAAOoB,OAAO,CAAC,EAAGb,EAAkBW,EAAMT,KAAMS,IACzF,EAUApB,EAAQS,kBAAoBA,EAO5BT,EAAQQ,iBANR,SAA0BG,EAAMC,EAAU,CAAC,GACvC,MAAO,CACHC,KAAM,sBACNU,UAAWP,KAAKC,UAAUN,EAAMO,EAAoBN,EAAQO,OAEpE,EAEA,MAAMK,EAAkBtB,OAAOuB,OAAO,CAClC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,WAEHC,EAAe,IAAIC,OAAO,IAAIzB,OAAO0B,KAAKJ,GAAiBK,KAAK,OAAQ,KACxEC,EAAmBC,GAAMP,EAAgBO,GAKzCb,EAGK,CAACc,EAAGzB,KACP,cAAeA,GACX,IAAK,SAED,GAAc,OAAVA,EACA,OAEJ,OAAOA,EACX,IAAK,SACL,IAAK,UACL,IAAK,SACD,OAAOA,EACX,IAAK,SACD,OAAOA,EAAM0B,QAAQP,EAAcI,GACvC,QAII,OAER,C,wEC3EynD,SAASI,EAAEC,EAAEC,GAAG,OAAOD,IAAIC,CAAC,CAAC,SAASC,EAAEF,EAAEC,GAAG,OAAOA,CAAC,CAAC,SAASE,EAAEF,EAAEL,EAAEO,GAAG,IAAIC,EAAED,GAAGA,EAAEE,YAAYN,EAAEO,GAAE,gBAAEJ,EAAED,GAAGM,EAAED,EAAE,GAAGE,EAAEF,EAAE,GAAGG,EAA7pD,SAAWC,EAAEC,EAAEC,GAAG,IAAIb,EAAEc,KAAKX,GAAE,YAAE,MAAMC,GAAE,YAAE,GAAGC,GAAE,YAAE,MAAME,GAAE,YAAE,IAAIC,GAAE,cAAIC,GAAE,cAAIC,GAAE,YAAEC,GAAGI,GAAE,aAAE,GAAIL,EAAEM,QAAQL,EAAE,IAAIM,EAAE,oBAAoBC,OAAOC,GAAGP,GAAG,IAAIA,GAAGK,EAAE,GAAG,mBAAmBN,EAAE,MAAM,IAAIS,UAAU,uBAAuBR,GAAGA,GAAG,EAAE,IAAIS,KAAKR,EAAEA,GAAG,CAAC,GAAGS,QAAQC,IAAI,aAAaV,MAAMA,EAAEW,SAASC,EAAE,YAAYZ,EAAEa,EAAE,qBAAqBb,KAAKA,EAAEc,iBAAiBC,EAAEH,EAAEI,KAAKC,KAAKjB,EAAEkB,SAAS,EAAEnB,GAAG,MAAK,gBAAE,WAAW,OAAOG,EAAEC,SAAQ,EAAG,WAAWD,EAAEC,SAAQ,CAAE,CAAC,GAAE,IAAI,IAAIgB,GAAE,cAAE,WAAW,IAAI/B,EAAE,SAASA,GAAG,IAAIC,EAAEK,EAAES,QAAQnB,EAAEW,EAAEQ,QAAQ,OAAOT,EAAES,QAAQR,EAAEQ,QAAQ,KAAKZ,EAAEY,QAAQf,EAAEQ,EAAEO,QAAQN,EAAEM,QAAQiB,MAAMpC,EAAEK,EAAE,EAAEA,EAAE,SAASD,EAAEC,GAAGiB,GAAGe,qBAAqB7B,EAAEW,SAASX,EAAEW,QAAQG,EAAEgB,sBAAsBlC,GAAGmC,WAAWnC,EAAEC,EAAE,EAAEL,EAAE,SAASI,GAAG,IAAIc,EAAEC,QAAQ,OAAM,EAAG,IAAId,EAAED,EAAEE,EAAEa,QAAQ,OAAOb,EAAEa,SAASd,GAAGU,GAAGV,EAAE,GAAGuB,GAAGxB,EAAEG,EAAEY,SAASY,CAAC,EAAEjB,EAAE,SAAST,GAAG,OAAOG,EAAEW,QAAQ,KAAKO,GAAGhB,EAAES,QAAQf,EAAEC,IAAIK,EAAES,QAAQR,EAAEQ,QAAQ,KAAKP,EAAEO,QAAQ,EAAEH,EAAE,SAASZ,IAAI,IAAIY,EAAEwB,KAAKC,MAAM,GAAGzC,EAAEgB,GAAG,OAAOF,EAAEE,GAAG,GAAGE,EAAEC,QAAQ,CAAC,IAAIhB,EAAEY,GAAGC,EAAEV,EAAEa,SAASX,EAAEoB,EAAEI,KAAKU,IAAIvC,EAAE4B,GAAGf,EAAET,EAAEY,UAAUhB,EAAEE,EAAED,EAAEI,EAAE,CAAC,EAAE2B,EAAE,WAAW,GAAGf,GAAGS,EAAE,CAAC,IAAIf,EAAE0B,KAAKC,MAAM5B,EAAEb,EAAEc,GAAG,GAAGJ,EAAES,QAAQ,GAAGwB,MAAMC,KAAKC,WAAWlC,EAAEQ,QAAQhB,EAAEG,EAAEa,QAAQL,EAAED,EAAE,CAAC,IAAIL,EAAEW,SAASD,EAAEC,QAAQ,OAAOZ,EAAEY,QAAQb,EAAEa,QAAQd,EAAEW,EAAED,GAAGS,EAAEpB,EAAEE,EAAEa,SAASP,EAAEO,QAAQ,GAAGS,EAAE,OAAOvB,EAAEW,EAAED,GAAGX,EAAEE,EAAEa,QAAQ,CAAC,OAAOX,EAAEW,SAASd,EAAEW,EAAED,GAAGH,EAAEO,OAAO,CAAC,EAAE,OAAOgB,EAAEW,OAAO,WAAWtC,EAAEW,UAAUG,EAAEe,qBAAqB7B,EAAEW,SAAS4B,aAAavC,EAAEW,UAAUZ,EAAEY,QAAQ,EAAET,EAAES,QAAQb,EAAEa,QAAQR,EAAEQ,QAAQX,EAAEW,QAAQ,IAAI,EAAEgB,EAAEa,UAAU,WAAW,QAAQxC,EAAEW,OAAO,EAAEgB,EAAEc,MAAM,WAAW,OAAOzC,EAAEW,QAAQL,EAAE0B,KAAKC,OAAO7B,EAAEO,OAAO,EAAEgB,CAAC,GAAE,CAACX,EAAEI,EAAEb,EAAEgB,EAAEL,EAAEJ,EAAEF,EAAES,IAAI,OAAOM,CAAC,CAA2HnB,EAAE,kBAAE,SAASZ,GAAG,OAAOQ,EAAER,EAAE,GAAE,CAACQ,IAAIZ,EAAEO,GAAGW,GAAE,YAAEb,GAAG,OAAOG,EAAEU,EAAEC,QAAQd,KAAKQ,EAAER,GAAGa,EAAEC,QAAQd,GAAG,CAACM,EAAEE,EAAE,C,wECKx1D,MAAM,MACJqC,EAAK,WACLC,EAAU,cACVC,EAAa,SACbC,EAAQ,YACRC,EAAW,QACXC,EAAO,IACPC,EAAG,OACHC,EAAM,aACNC,EAAY,OACZC,EAAM,WACNC,EAAU,aACVC,EAAY,eACZC,EAAc,WACdC,EAAU,WACVC,EAAU,YACVC,GACE,G,wECaJ,MAAMC,EAAc,IAAIC,IAClBC,EAAU,IAAIC,QACpB,IACIC,EADAC,EAAS,EAsFb,SAASC,EAAQC,EAASC,EAAU7F,EAAU,CAAC,EAAG8F,EAAiBL,GACjE,QAA2C,IAAhCjD,OAAOuD,2BAA2DC,IAAnBF,EAA8B,CACtF,MAAMG,EAASL,EAAQM,wBAUvB,OATAL,EAASC,EAAgB,CACvBK,eAAgBL,EAChBM,OAAQR,EACRS,kBAAgD,iBAAtBrG,EAAQsG,UAAyBtG,EAAQsG,UAAY,EAC/EC,KAAM,EACNC,mBAAoBP,EACpBQ,iBAAkBR,EAClBS,WAAYT,IAEP,MAET,CAGA,MAAM,GACJU,EAAE,SACFC,EAAQ,SACRC,GArEJ,SAAwB7G,GAEtB,IAAI2G,EARN,SAAqB3G,GACnB,OAAOV,OAAO0B,KAAKhB,GAAS8G,OAAOC,QAAOC,QAAwBhB,IAAjBhG,EAAQgH,KAAoBC,KAAID,IAC/E,MAAO,GAAGA,KAAe,SAARA,GAhBFE,EAgB6BlH,EAAQkH,KAfjDA,GACD3B,EAAQ4B,IAAID,KAChBxB,GAAU,EACVH,EAAQ6B,IAAIF,EAAMxB,EAAO2B,aAFK9B,EAAQ9F,IAAIyH,IADxB,KAe4ClH,EAAQgH,KAhBxE,IAAmBE,CAgB2D,IACzEG,UACL,CAIWC,CAAYtH,GACjBuH,EAAWlC,EAAY5F,IAAIkH,GAE/B,IAAKY,EAAU,CAEb,MAAMV,EAAW,IAAIvB,IACrB,IAAIkC,EACJ,MAAMZ,EAAW,IAAIb,sBAAqB0B,IACxCA,EAAQC,SAAQC,IACd,IAAIC,EAIJ,MAAMC,EAASF,EAAMxB,gBAAkBqB,EAAWM,MAAKxB,GAAaqB,EAAMtB,mBAAqBC,IAE3FtG,EAAQ+H,sBAA8C,IAApBJ,EAAMK,YAG1CL,EAAMK,UAAYH,GAG4B,OAA/CD,EAAgBf,EAASpH,IAAIkI,EAAMvB,UAA4BwB,EAAcF,SAAQ7B,IACpFA,EAASgC,EAAQF,EAAM,GACvB,GACF,GACD3H,GAEHwH,EAAaZ,EAASY,aAAeS,MAAMC,QAAQlI,EAAQsG,WAAatG,EAAQsG,UAAY,CAACtG,EAAQsG,WAAa,IAClHiB,EAAW,CACTZ,KACAC,WACAC,YAEFxB,EAAY+B,IAAIT,EAAIY,EACtB,CAEA,OAAOA,CACT,CA+BMY,CAAenI,GAEnB,IAAIoI,EAAYvB,EAASpH,IAAImG,IAAY,GAQzC,OANKiB,EAASM,IAAIvB,IAChBiB,EAASO,IAAIxB,EAASwC,GAGxBA,EAAUC,KAAKxC,GACfe,EAASjB,QAAQC,GACV,WAELwC,EAAUE,OAAOF,EAAUG,QAAQ1C,GAAW,GAErB,IAArBuC,EAAUI,SAEZ3B,EAAS4B,OAAO7C,GAChBgB,EAAS8B,UAAU9C,IAGC,IAAlBiB,EAAS8B,OAEX/B,EAASgC,aACTvD,EAAYoD,OAAO9B,GAEvB,CACF,CA6MA,SAASkC,GAAU,UACjBvC,EAAS,MACTwC,EAAK,gBACLf,EAAe,WACfgB,EAAU,KACV7B,EAAI,YACJ8B,EAAW,KACXC,EAAI,cACJC,EAAa,eACbpD,EAAc,SACdqD,GACE,CAAC,GACH,IAAIC,EAEJ,MAAOC,EAAKC,GAAU,WAAe,MAC/BzD,EAAW,YACV0D,EAAOC,GAAY,WAAe,CACvC3B,SAAUqB,EACVvB,WAAO3B,IAITH,EAASvD,QAAU6G,EACnB,aAAgB,KAEd,GAAIF,IAASI,EAAK,OAClB,IAAIX,EAsBJ,OArBAA,EAAY/C,EAAQ0D,GAAK,CAACxB,EAAQF,KAChC6B,EAAS,CACP3B,SACAF,UAEE9B,EAASvD,SAASuD,EAASvD,QAAQuF,EAAQF,GAE3CA,EAAMxB,gBAAkB6C,GAAeN,IAEzCA,IACAA,OAAY1C,EACd,GACC,CACDkB,OACA6B,aACAzC,YAEAyB,kBAEAe,SACChD,GACI,KACD4C,GACFA,GACF,CACD,GAGH,CAEAT,MAAMC,QAAQ5B,GAAaA,EAAUe,WAAaf,EAAW+C,EAAKnC,EAAM6B,EAAYC,EAAaC,EAAMlB,EAAiBjC,EAAgBgD,IACxI,MAAMW,EAA8C,OAA/BL,EAAeG,EAAM5B,YAAiB,EAASyB,EAAahD,OAC3EsD,EAAsB,WAEvBL,IAAOI,GAAgBT,GAAgBC,GAAQS,EAAoBpH,UAAYmH,IAGlFC,EAAoBpH,QAAUmH,EAC9BD,EAAS,CACP3B,SAAUqB,EACVvB,WAAO3B,KAIX,MAAM2D,EAAS,CAACL,EAAQC,EAAM1B,OAAQ0B,EAAM5B,OAK5C,OAHAgC,EAAON,IAAMM,EAAO,GACpBA,EAAO9B,OAAS8B,EAAO,GACvBA,EAAOhC,MAAQgC,EAAO,GACfA,CACT,CAhOqB,W","sources":["webpack:///../../node_modules/react-schemaorg/dist/src/index.js","webpack:///../../node_modules/react-schemaorg/dist/src/json-ld.js","webpack:///../../node_modules/use-debounce/dist/index.module.js","webpack:///./node_modules/axios/index.js","webpack:///../../node_modules/react-intersection-observer/react-intersection-observer.modern.mjs"],"sourcesContent":["\"use strict\";\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.jsonLdScriptProps = exports.JsonLd = exports.helmetJsonLdProp = void 0;\nvar json_ld_1 = require(\"./json-ld\");\nObject.defineProperty(exports, \"helmetJsonLdProp\", { enumerable: true, get: function () { return json_ld_1.helmetJsonLdProp; } });\nObject.defineProperty(exports, \"JsonLd\", { enumerable: true, get: function () { return json_ld_1.JsonLd; } });\nObject.defineProperty(exports, \"jsonLdScriptProps\", { enumerable: true, get: function () { return json_ld_1.jsonLdScriptProps; } });\n","\"use strict\";\n/**\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.helmetJsonLdProp = exports.jsonLdScriptProps = exports.JsonLd = void 0;\nconst React = require(\"react\");\nfunction JsonLd(props) {\n    return React.createElement(\"script\", Object.assign({}, jsonLdScriptProps(props.item, props)));\n}\nexports.JsonLd = JsonLd;\nfunction jsonLdScriptProps(item, options = {}) {\n    return {\n        type: \"application/ld+json\",\n        dangerouslySetInnerHTML: {\n            __html: JSON.stringify(item, safeJsonLdReplacer, options.space),\n        },\n    };\n}\nexports.jsonLdScriptProps = jsonLdScriptProps;\nfunction helmetJsonLdProp(item, options = {}) {\n    return {\n        type: \"application/ld+json\",\n        innerHTML: JSON.stringify(item, safeJsonLdReplacer, options.space),\n    };\n}\nexports.helmetJsonLdProp = helmetJsonLdProp;\nconst ESCAPE_ENTITIES = Object.freeze({\n    \"&\": \"&amp;\",\n    \"<\": \"&lt;\",\n    \">\": \"&gt;\",\n    '\"': \"&quot;\",\n    \"'\": \"&apos;\",\n});\nconst ESCAPE_REGEX = new RegExp(`[${Object.keys(ESCAPE_ENTITIES).join(\"\")}]`, \"g\");\nconst ESCAPE_REPLACER = (t) => ESCAPE_ENTITIES[t];\n/**\n * A replacer for JSON.stringify to strip JSON-LD of illegal HTML entities\n * per https://www.w3.org/TR/json-ld11/#restrictions-for-contents-of-json-ld-script-elements\n */\nconst safeJsonLdReplacer = (() => {\n    // Replace per https://www.w3.org/TR/json-ld11/#restrictions-for-contents-of-json-ld-script-elements\n    // Solution from https://stackoverflow.com/a/5499821/864313\n    return (_, value) => {\n        switch (typeof value) {\n            case \"object\":\n                // Omit null values.\n                if (value === null) {\n                    return undefined;\n                }\n                return value; // JSON.stringify will recursively call replacer.\n            case \"number\":\n            case \"boolean\":\n            case \"bigint\":\n                return value; // These values are not risky.\n            case \"string\":\n                return value.replace(ESCAPE_REGEX, ESCAPE_REPLACER);\n            default: {\n                // We shouldn't expect other types.\n                isNever(value);\n                // JSON.stringify will remove this element.\n                return undefined;\n            }\n        }\n    };\n})();\n// Utility: Assert never\nfunction isNever(_) { }\n","import{useRef as r,useEffect as n,useMemo as t,useReducer as e,useCallback as u}from\"react\";function c(e,u,c){var i=this,a=r(null),o=r(0),f=r(null),l=r([]),v=r(),m=r(),d=r(e),g=r(!0);d.current=e;var p=\"undefined\"!=typeof window,w=!u&&0!==u&&p;if(\"function\"!=typeof e)throw new TypeError(\"Expected a function\");u=+u||0;var s=!!(c=c||{}).leading,x=!(\"trailing\"in c)||!!c.trailing,h=\"maxWait\"in c,y=\"debounceOnServer\"in c&&!!c.debounceOnServer,F=h?Math.max(+c.maxWait||0,u):null;n(function(){return g.current=!0,function(){g.current=!1}},[]);var A=t(function(){var r=function(r){var n=l.current,t=v.current;return l.current=v.current=null,o.current=r,m.current=d.current.apply(t,n)},n=function(r,n){w&&cancelAnimationFrame(f.current),f.current=w?requestAnimationFrame(r):setTimeout(r,n)},t=function(r){if(!g.current)return!1;var n=r-a.current;return!a.current||n>=u||n<0||h&&r-o.current>=F},e=function(n){return f.current=null,x&&l.current?r(n):(l.current=v.current=null,m.current)},c=function r(){var c=Date.now();if(t(c))return e(c);if(g.current){var i=u-(c-a.current),f=h?Math.min(i,F-(c-o.current)):i;n(r,f)}},A=function(){if(p||y){var e=Date.now(),d=t(e);if(l.current=[].slice.call(arguments),v.current=i,a.current=e,d){if(!f.current&&g.current)return o.current=a.current,n(c,u),s?r(a.current):m.current;if(h)return n(c,u),r(a.current)}return f.current||n(c,u),m.current}};return A.cancel=function(){f.current&&(w?cancelAnimationFrame(f.current):clearTimeout(f.current)),o.current=0,l.current=a.current=v.current=f.current=null},A.isPending=function(){return!!f.current},A.flush=function(){return f.current?e(Date.now()):m.current},A},[s,h,u,F,x,w,p,y]);return A}function i(r,n){return r===n}function a(r,n){return n}function o(n,t,o){var f=o&&o.equalityFn||i,l=e(a,n),v=l[0],m=l[1],d=c(u(function(r){return m(r)},[m]),t,o),g=r(n);return f(g.current,n)||(d(n),g.current=n),[v,d]}function f(r,n,t){var e=void 0===t?{}:t,u=e.leading,i=e.trailing;return c(r,n,{maxWait:n,leading:void 0===u||u,trailing:void 0===i||i})}export{o as useDebounce,c as useDebouncedCallback,f as useThrottledCallback};\n//# sourceMappingURL=index.module.js.map\n","import axios from './lib/axios.js';\n\n// This module is intended to unwrap Axios default export as named.\n// Keep top-level export same with static properties\n// so that it can keep same with es module or cjs\nconst {\n  Axios,\n  AxiosError,\n  CanceledError,\n  isCancel,\n  CancelToken,\n  VERSION,\n  all,\n  Cancel,\n  isAxiosError,\n  spread,\n  toFormData,\n  AxiosHeaders,\n  HttpStatusCode,\n  formToJSON,\n  getAdapter,\n  mergeConfig\n} = axios;\n\nexport {\n  axios as default,\n  Axios,\n  AxiosError,\n  CanceledError,\n  isCancel,\n  CancelToken,\n  VERSION,\n  all,\n  Cancel,\n  isAxiosError,\n  spread,\n  toFormData,\n  AxiosHeaders,\n  HttpStatusCode,\n  formToJSON,\n  getAdapter,\n  mergeConfig\n}\n","import * as React from 'react';\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nconst observerMap = new Map();\nconst RootIds = new WeakMap();\nlet rootId = 0;\nlet unsupportedValue = undefined;\n/**\r\n * What should be the default behavior if the IntersectionObserver is unsupported?\r\n * Ideally the polyfill has been loaded, you can have the following happen:\r\n * - `undefined`: Throw an error\r\n * - `true` or `false`: Set the `inView` value to this regardless of intersection state\r\n * **/\n\nfunction defaultFallbackInView(inView) {\n  unsupportedValue = inView;\n}\n/**\r\n * Generate a unique ID for the root element\r\n * @param root\r\n */\n\nfunction getRootId(root) {\n  if (!root) return '0';\n  if (RootIds.has(root)) return RootIds.get(root);\n  rootId += 1;\n  RootIds.set(root, rootId.toString());\n  return RootIds.get(root);\n}\n/**\r\n * Convert the options to a string Id, based on the values.\r\n * Ensures we can reuse the same observer when observing elements with the same options.\r\n * @param options\r\n */\n\n\nfunction optionsToId(options) {\n  return Object.keys(options).sort().filter(key => options[key] !== undefined).map(key => {\n    return `${key}_${key === 'root' ? getRootId(options.root) : options[key]}`;\n  }).toString();\n}\n\nfunction createObserver(options) {\n  // Create a unique ID for this observer instance, based on the root, root margin and threshold.\n  let id = optionsToId(options);\n  let instance = observerMap.get(id);\n\n  if (!instance) {\n    // Create a map of elements this observer is going to observe. Each element has a list of callbacks that should be triggered, once it comes into view.\n    const elements = new Map();\n    let thresholds;\n    const observer = new IntersectionObserver(entries => {\n      entries.forEach(entry => {\n        var _elements$get;\n\n        // While it would be nice if you could just look at isIntersecting to determine if the component is inside the viewport, browsers can't agree on how to use it.\n        // -Firefox ignores `threshold` when considering `isIntersecting`, so it will never be false again if `threshold` is > 0\n        const inView = entry.isIntersecting && thresholds.some(threshold => entry.intersectionRatio >= threshold); // @ts-ignore support IntersectionObserver v2\n\n        if (options.trackVisibility && typeof entry.isVisible === 'undefined') {\n          // The browser doesn't support Intersection Observer v2, falling back to v1 behavior.\n          // @ts-ignore\n          entry.isVisible = inView;\n        }\n\n        (_elements$get = elements.get(entry.target)) == null ? void 0 : _elements$get.forEach(callback => {\n          callback(inView, entry);\n        });\n      });\n    }, options); // Ensure we have a valid thresholds array. If not, use the threshold from the options\n\n    thresholds = observer.thresholds || (Array.isArray(options.threshold) ? options.threshold : [options.threshold || 0]);\n    instance = {\n      id,\n      observer,\n      elements\n    };\n    observerMap.set(id, instance);\n  }\n\n  return instance;\n}\n/**\r\n * @param element - DOM Element to observe\r\n * @param callback - Callback function to trigger when intersection status changes\r\n * @param options - Intersection Observer options\r\n * @param fallbackInView - Fallback inView value.\r\n * @return Function - Cleanup function that should be triggered to unregister the observer\r\n */\n\n\nfunction observe(element, callback, options = {}, fallbackInView = unsupportedValue) {\n  if (typeof window.IntersectionObserver === 'undefined' && fallbackInView !== undefined) {\n    const bounds = element.getBoundingClientRect();\n    callback(fallbackInView, {\n      isIntersecting: fallbackInView,\n      target: element,\n      intersectionRatio: typeof options.threshold === 'number' ? options.threshold : 0,\n      time: 0,\n      boundingClientRect: bounds,\n      intersectionRect: bounds,\n      rootBounds: bounds\n    });\n    return () => {// Nothing to cleanup\n    };\n  } // An observer with the same options can be reused, so lets use this fact\n\n\n  const {\n    id,\n    observer,\n    elements\n  } = createObserver(options); // Register the callback listener for this element\n\n  let callbacks = elements.get(element) || [];\n\n  if (!elements.has(element)) {\n    elements.set(element, callbacks);\n  }\n\n  callbacks.push(callback);\n  observer.observe(element);\n  return function unobserve() {\n    // Remove the callback from the callback list\n    callbacks.splice(callbacks.indexOf(callback), 1);\n\n    if (callbacks.length === 0) {\n      // No more callback exists for element, so destroy it\n      elements.delete(element);\n      observer.unobserve(element);\n    }\n\n    if (elements.size === 0) {\n      // No more elements are being observer by this instance, so destroy it\n      observer.disconnect();\n      observerMap.delete(id);\n    }\n  };\n}\n\nconst _excluded = [\"children\", \"as\", \"triggerOnce\", \"threshold\", \"root\", \"rootMargin\", \"onChange\", \"skip\", \"trackVisibility\", \"delay\", \"initialInView\", \"fallbackInView\"];\n\nfunction isPlainChildren(props) {\n  return typeof props.children !== 'function';\n}\n/**\r\n ## Render props\r\n\n To use the `<InView>` component, you pass it a function. It will be called\r\n whenever the state changes, with the new value of `inView`. In addition to the\r\n `inView` prop, children also receive a `ref` that should be set on the\r\n containing DOM element. This is the element that the IntersectionObserver will\r\n monitor.\r\n\n If you need it, you can also access the\r\n [`IntersectionObserverEntry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry)\r\n on `entry`, giving you access to all the details about the current intersection\r\n state.\r\n\n ```jsx\r\n import { InView } from 'react-intersection-observer';\r\n\n const Component = () => (\r\n <InView>\r\n {({ inView, ref, entry }) => (\r\n      <div ref={ref}>\r\n        <h2>{`Header inside viewport ${inView}.`}</h2>\r\n      </div>\r\n    )}\r\n </InView>\r\n );\r\n\n export default Component;\r\n ```\r\n\n ## Plain children\r\n\n You can pass any element to the `<InView />`, and it will handle creating the\r\n wrapping DOM element. Add a handler to the `onChange` method, and control the\r\n state in your own component. Any extra props you add to `<InView>` will be\r\n passed to the HTML element, allowing you set the `className`, `style`, etc.\r\n\n ```jsx\r\n import { InView } from 'react-intersection-observer';\r\n\n const Component = () => (\r\n <InView as=\"div\" onChange={(inView, entry) => console.log('Inview:', inView)}>\r\n <h2>Plain children are always rendered. Use onChange to monitor state.</h2>\r\n </InView>\r\n );\r\n\n export default Component;\r\n ```\r\n */\n\n\nclass InView extends React.Component {\n  constructor(props) {\n    super(props);\n    this.node = null;\n    this._unobserveCb = null;\n\n    this.handleNode = node => {\n      if (this.node) {\n        // Clear the old observer, before we start observing a new element\n        this.unobserve();\n\n        if (!node && !this.props.triggerOnce && !this.props.skip) {\n          // Reset the state if we get a new node, and we aren't ignoring updates\n          this.setState({\n            inView: !!this.props.initialInView,\n            entry: undefined\n          });\n        }\n      }\n\n      this.node = node ? node : null;\n      this.observeNode();\n    };\n\n    this.handleChange = (inView, entry) => {\n      if (inView && this.props.triggerOnce) {\n        // If `triggerOnce` is true, we should stop observing the element.\n        this.unobserve();\n      }\n\n      if (!isPlainChildren(this.props)) {\n        // Store the current State, so we can pass it to the children in the next render update\n        // There's no reason to update the state for plain children, since it's not used in the rendering.\n        this.setState({\n          inView,\n          entry\n        });\n      }\n\n      if (this.props.onChange) {\n        // If the user is actively listening for onChange, always trigger it\n        this.props.onChange(inView, entry);\n      }\n    };\n\n    this.state = {\n      inView: !!props.initialInView,\n      entry: undefined\n    };\n  }\n\n  componentDidUpdate(prevProps) {\n    // If a IntersectionObserver option changed, reinit the observer\n    if (prevProps.rootMargin !== this.props.rootMargin || prevProps.root !== this.props.root || prevProps.threshold !== this.props.threshold || prevProps.skip !== this.props.skip || prevProps.trackVisibility !== this.props.trackVisibility || prevProps.delay !== this.props.delay) {\n      this.unobserve();\n      this.observeNode();\n    }\n  }\n\n  componentWillUnmount() {\n    this.unobserve();\n    this.node = null;\n  }\n\n  observeNode() {\n    if (!this.node || this.props.skip) return;\n    const {\n      threshold,\n      root,\n      rootMargin,\n      trackVisibility,\n      delay,\n      fallbackInView\n    } = this.props;\n    this._unobserveCb = observe(this.node, this.handleChange, {\n      threshold,\n      root,\n      rootMargin,\n      // @ts-ignore\n      trackVisibility,\n      // @ts-ignore\n      delay\n    }, fallbackInView);\n  }\n\n  unobserve() {\n    if (this._unobserveCb) {\n      this._unobserveCb();\n\n      this._unobserveCb = null;\n    }\n  }\n\n  render() {\n    if (!isPlainChildren(this.props)) {\n      const {\n        inView,\n        entry\n      } = this.state;\n      return this.props.children({\n        inView,\n        entry,\n        ref: this.handleNode\n      });\n    }\n\n    const _this$props = this.props,\n          {\n      children,\n      as\n    } = _this$props,\n          props = _objectWithoutPropertiesLoose(_this$props, _excluded);\n\n    return React.createElement(as || 'div', _extends({\n      ref: this.handleNode\n    }, props), children);\n  }\n\n}\n\n/**\r\n * React Hooks make it easy to monitor the `inView` state of your components. Call\r\n * the `useInView` hook with the (optional) [options](#options) you need. It will\r\n * return an array containing a `ref`, the `inView` status and the current\r\n * [`entry`](https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserverEntry).\r\n * Assign the `ref` to the DOM element you want to monitor, and the hook will\r\n * report the status.\r\n *\r\n * @example\r\n * ```jsx\r\n * import React from 'react';\r\n * import { useInView } from 'react-intersection-observer';\r\n *\r\n * const Component = () => {\r\n *   const { ref, inView, entry } = useInView({\r\n *       threshold: 0,\r\n *   });\r\n *\r\n *   return (\r\n *     <div ref={ref}>\r\n *       <h2>{`Header inside viewport ${inView}.`}</h2>\r\n *     </div>\r\n *   );\r\n * };\r\n * ```\r\n */\n\nfunction useInView({\n  threshold,\n  delay,\n  trackVisibility,\n  rootMargin,\n  root,\n  triggerOnce,\n  skip,\n  initialInView,\n  fallbackInView,\n  onChange\n} = {}) {\n  var _state$entry;\n\n  const [ref, setRef] = React.useState(null);\n  const callback = React.useRef();\n  const [state, setState] = React.useState({\n    inView: !!initialInView,\n    entry: undefined\n  }); // Store the onChange callback in a `ref`, so we can access the latest instance\n  // inside the `useEffect`, but without triggering a rerender.\n\n  callback.current = onChange;\n  React.useEffect(() => {\n    // Ensure we have node ref, and that we shouldn't skip observing\n    if (skip || !ref) return;\n    let unobserve;\n    unobserve = observe(ref, (inView, entry) => {\n      setState({\n        inView,\n        entry\n      });\n      if (callback.current) callback.current(inView, entry);\n\n      if (entry.isIntersecting && triggerOnce && unobserve) {\n        // If it should only trigger once, unobserve the element after it's inView\n        unobserve();\n        unobserve = undefined;\n      }\n    }, {\n      root,\n      rootMargin,\n      threshold,\n      // @ts-ignore\n      trackVisibility,\n      // @ts-ignore\n      delay\n    }, fallbackInView);\n    return () => {\n      if (unobserve) {\n        unobserve();\n      }\n    };\n  }, // We break the rule here, because we aren't including the actual `threshold` variable\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  [// If the threshold is an array, convert it to a string, so it won't change between renders.\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  Array.isArray(threshold) ? threshold.toString() : threshold, ref, root, rootMargin, triggerOnce, skip, trackVisibility, fallbackInView, delay]);\n  const entryTarget = (_state$entry = state.entry) == null ? void 0 : _state$entry.target;\n  const previousEntryTarget = React.useRef();\n\n  if (!ref && entryTarget && !triggerOnce && !skip && previousEntryTarget.current !== entryTarget) {\n    // If we don't have a node ref, then reset the state (unless the hook is set to only `triggerOnce` or `skip`)\n    // This ensures we correctly reflect the current state - If you aren't observing anything, then nothing is inView\n    previousEntryTarget.current = entryTarget;\n    setState({\n      inView: !!initialInView,\n      entry: undefined\n    });\n  }\n\n  const result = [setRef, state.inView, state.entry]; // Support object destructuring, by adding the specific values.\n\n  result.ref = result[0];\n  result.inView = result[1];\n  result.entry = result[2];\n  return result;\n}\n\nexport { InView, defaultFallbackInView, observe, useInView };\n//# sourceMappingURL=react-intersection-observer.modern.mjs.map\n"],"names":["exports","json_ld_1","Object","defineProperty","enumerable","get","JsonLd","value","helmetJsonLdProp","jsonLdScriptProps","React","item","options","type","dangerouslySetInnerHTML","__html","JSON","stringify","safeJsonLdReplacer","space","props","createElement","assign","innerHTML","ESCAPE_ENTITIES","freeze","ESCAPE_REGEX","RegExp","keys","join","ESCAPE_REPLACER","t","_","replace","i","r","n","a","o","f","equalityFn","l","v","m","d","e","u","c","this","g","current","p","window","w","TypeError","s","leading","x","trailing","h","y","debounceOnServer","F","Math","max","maxWait","A","apply","cancelAnimationFrame","requestAnimationFrame","setTimeout","Date","now","min","slice","call","arguments","cancel","clearTimeout","isPending","flush","Axios","AxiosError","CanceledError","isCancel","CancelToken","VERSION","all","Cancel","isAxiosError","spread","toFormData","AxiosHeaders","HttpStatusCode","formToJSON","getAdapter","mergeConfig","observerMap","Map","RootIds","WeakMap","unsupportedValue","rootId","observe","element","callback","fallbackInView","IntersectionObserver","undefined","bounds","getBoundingClientRect","isIntersecting","target","intersectionRatio","threshold","time","boundingClientRect","intersectionRect","rootBounds","id","observer","elements","sort","filter","key","map","root","has","set","toString","optionsToId","instance","thresholds","entries","forEach","entry","_elements$get","inView","some","trackVisibility","isVisible","Array","isArray","createObserver","callbacks","push","splice","indexOf","length","delete","unobserve","size","disconnect","useInView","delay","rootMargin","triggerOnce","skip","initialInView","onChange","_state$entry","ref","setRef","state","setState","entryTarget","previousEntryTarget","result"],"sourceRoot":""}