@adartem/adlib-attributes 0.1.4 → 0.1.5

package/dist/dist-M6QCD7TL.js

@@ -0,0 +1,4281 @@
+import {
+  functionThrottle
+} from "./chunk-NS2GB4WB.js";
+import {
+  require_just_debounce
+} from "./chunk-M2KO765Q.js";
+import {
+  $o,
+  $t,
+  A,
+  Bt,
+  Dn,
+  Do,
+  Dt,
+  F,
+  Fn,
+  Ft,
+  Ht,
+  Jo,
+  K,
+  Kn,
+  Mn,
+  Mo,
+  Nt,
+  Po,
+  Qt,
+  Sn,
+  Un,
+  Vo,
+  Wt,
+  Xt,
+  Yo,
+  Yt,
+  __commonJS,
+  __toESM,
+  _n,
+  be,
+  ce,
+  co,
+  gt,
+  ie,
+  init_live_reload,
+  j,
+  jo,
+  kn,
+  on,
+  q,
+  qo,
+  rn,
+  rr,
+  sn,
+  tn,
+  tr,
+  uo,
+  vn,
+  vo,
+  vt,
+  wn,
+  xn,
+  zo
+} from "./chunk-IEGIKJKW.js";
+
+// ../../node_modules/fuzzysort/fuzzysort.js
+var require_fuzzysort = __commonJS({
+  "../../node_modules/fuzzysort/fuzzysort.js"(exports, module) {
+    init_live_reload();
+    ((root, UMD) => {
+      if (typeof define === "function" && define.amd) define([], UMD);
+      else if (typeof module === "object" && module.exports) module.exports = UMD();
+      else root["fuzzysort"] = UMD();
+    })(exports, (_2) => {
+      "use strict";
+      var single = (search, target) => {
+        if (!search || !target) return NULL;
+        var preparedSearch = getPreparedSearch(search);
+        if (!isPrepared(target)) target = getPrepared(target);
+        var searchBitflags = preparedSearch.bitflags;
+        if ((searchBitflags & target._bitflags) !== searchBitflags) return NULL;
+        return algorithm(preparedSearch, target);
+      };
+      var go2 = (search, targets, options) => {
+        if (!search) return options?.all ? all(targets, options) : noResults;
+        var preparedSearch = getPreparedSearch(search);
+        var searchBitflags = preparedSearch.bitflags;
+        var containsSpace = preparedSearch.containsSpace;
+        var threshold = denormalizeScore(options?.threshold || 0);
+        var limit = options?.limit || INFINITY;
+        var resultsLen = 0;
+        var limitedCount = 0;
+        var targetsLen = targets.length;
+        function push_result(result2) {
+          if (resultsLen < limit) {
+            q3.add(result2);
+            ++resultsLen;
+          } else {
+            ++limitedCount;
+            if (result2._score > q3.peek()._score) q3.replaceTop(result2);
+          }
+        }
+        if (options?.key) {
+          var key = options.key;
+          for (var i = 0; i < targetsLen; ++i) {
+            var obj = targets[i];
+            var target = getValue(obj, key);
+            if (!target) continue;
+            if (!isPrepared(target)) target = getPrepared(target);
+            if ((searchBitflags & target._bitflags) !== searchBitflags) continue;
+            var result = algorithm(preparedSearch, target);
+            if (result === NULL) continue;
+            if (result._score < threshold) continue;
+            result.obj = obj;
+            push_result(result);
+          }
+        } else if (options?.keys) {
+          var keys = options.keys;
+          var keysLen = keys.length;
+          outer: for (var i = 0; i < targetsLen; ++i) {
+            var obj = targets[i];
+            {
+              var keysBitflags = 0;
+              for (var keyI = 0; keyI < keysLen; ++keyI) {
+                var key = keys[keyI];
+                var target = getValue(obj, key);
+                if (!target) {
+                  tmpTargets[keyI] = noTarget;
+                  continue;
+                }
+                if (!isPrepared(target)) target = getPrepared(target);
+                tmpTargets[keyI] = target;
+                keysBitflags |= target._bitflags;
+              }
+              if ((searchBitflags & keysBitflags) !== searchBitflags) continue;
+            }
+            if (containsSpace) for (let i2 = 0; i2 < preparedSearch.spaceSearches.length; i2++) keysSpacesBestScores[i2] = NEGATIVE_INFINITY;
+            for (var keyI = 0; keyI < keysLen; ++keyI) {
+              target = tmpTargets[keyI];
+              if (target === noTarget) {
+                tmpResults[keyI] = noTarget;
+                continue;
+              }
+              tmpResults[keyI] = algorithm(
+                preparedSearch,
+                target,
+                /*allowSpaces=*/
+                false,
+                /*allowPartialMatch=*/
+                containsSpace
+              );
+              if (tmpResults[keyI] === NULL) {
+                tmpResults[keyI] = noTarget;
+                continue;
+              }
+              if (containsSpace) for (let i2 = 0; i2 < preparedSearch.spaceSearches.length; i2++) {
+                if (allowPartialMatchScores[i2] > -1e3) {
+                  if (keysSpacesBestScores[i2] > NEGATIVE_INFINITY) {
+                    var tmp = (keysSpacesBestScores[i2] + allowPartialMatchScores[i2]) / 4;
+                    if (tmp > keysSpacesBestScores[i2]) keysSpacesBestScores[i2] = tmp;
+                  }
+                }
+                if (allowPartialMatchScores[i2] > keysSpacesBestScores[i2]) keysSpacesBestScores[i2] = allowPartialMatchScores[i2];
+              }
+            }
+            if (containsSpace) {
+              for (let i2 = 0; i2 < preparedSearch.spaceSearches.length; i2++) {
+                if (keysSpacesBestScores[i2] === NEGATIVE_INFINITY) continue outer;
+              }
+            } else {
+              var hasAtLeast1Match = false;
+              for (let i2 = 0; i2 < keysLen; i2++) {
+                if (tmpResults[i2]._score !== NEGATIVE_INFINITY) {
+                  hasAtLeast1Match = true;
+                  break;
+                }
+              }
+              if (!hasAtLeast1Match) continue;
+            }
+            var objResults = new KeysResult(keysLen);
+            for (let i2 = 0; i2 < keysLen; i2++) {
+              objResults[i2] = tmpResults[i2];
+            }
+            if (containsSpace) {
+              var score = 0;
+              for (let i2 = 0; i2 < preparedSearch.spaceSearches.length; i2++) score += keysSpacesBestScores[i2];
+            } else {
+              var score = NEGATIVE_INFINITY;
+              for (let i2 = 0; i2 < keysLen; i2++) {
+                var result = objResults[i2];
+                if (result._score > -1e3) {
+                  if (score > NEGATIVE_INFINITY) {
+                    var tmp = (score + result._score) / 4;
+                    if (tmp > score) score = tmp;
+                  }
+                }
+                if (result._score > score) score = result._score;
+              }
+            }
+            objResults.obj = obj;
+            objResults._score = score;
+            if (options?.scoreFn) {
+              score = options.scoreFn(objResults);
+              if (!score) continue;
+              score = denormalizeScore(score);
+              objResults._score = score;
+            }
+            if (score < threshold) continue;
+            push_result(objResults);
+          }
+        } else {
+          for (var i = 0; i < targetsLen; ++i) {
+            var target = targets[i];
+            if (!target) continue;
+            if (!isPrepared(target)) target = getPrepared(target);
+            if ((searchBitflags & target._bitflags) !== searchBitflags) continue;
+            var result = algorithm(preparedSearch, target);
+            if (result === NULL) continue;
+            if (result._score < threshold) continue;
+            push_result(result);
+          }
+        }
+        if (resultsLen === 0) return noResults;
+        var results = new Array(resultsLen);
+        for (var i = resultsLen - 1; i >= 0; --i) results[i] = q3.poll();
+        results.total = resultsLen + limitedCount;
+        return results;
+      };
+      var highlight = (result, open = "<b>", close = "</b>") => {
+        var callback = typeof open === "function" ? open : void 0;
+        var target = result.target;
+        var targetLen = target.length;
+        var indexes = result.indexes;
+        var highlighted = "";
+        var matchI = 0;
+        var indexesI = 0;
+        var opened = false;
+        var parts = [];
+        for (var i = 0; i < targetLen; ++i) {
+          var char = target[i];
+          if (indexes[indexesI] === i) {
+            ++indexesI;
+            if (!opened) {
+              opened = true;
+              if (callback) {
+                parts.push(highlighted);
+                highlighted = "";
+              } else {
+                highlighted += open;
+              }
+            }
+            if (indexesI === indexes.length) {
+              if (callback) {
+                highlighted += char;
+                parts.push(callback(highlighted, matchI++));
+                highlighted = "";
+                parts.push(target.substr(i + 1));
+              } else {
+                highlighted += char + close + target.substr(i + 1);
+              }
+              break;
+            }
+          } else {
+            if (opened) {
+              opened = false;
+              if (callback) {
+                parts.push(callback(highlighted, matchI++));
+                highlighted = "";
+              } else {
+                highlighted += close;
+              }
+            }
+          }
+          highlighted += char;
+        }
+        return callback ? parts : highlighted;
+      };
+      var prepare = (target) => {
+        if (typeof target === "number") target = "" + target;
+        else if (typeof target !== "string") target = "";
+        var info = prepareLowerInfo(target);
+        return new_result(target, { _targetLower: info._lower, _targetLowerCodes: info.lowerCodes, _bitflags: info.bitflags });
+      };
+      var cleanup = () => {
+        preparedCache.clear();
+        preparedSearchCache.clear();
+      };
+      class Result {
+        get ["indexes"]() {
+          return this._indexes.slice(0, this._indexes.len).sort((a, b) => a - b);
+        }
+        set ["indexes"](indexes) {
+          return this._indexes = indexes;
+        }
+        ["highlight"](open, close) {
+          return highlight(this, open, close);
+        }
+        get ["score"]() {
+          return normalizeScore(this._score);
+        }
+        set ["score"](score) {
+          this._score = denormalizeScore(score);
+        }
+      }
+      class KeysResult extends Array {
+        get ["score"]() {
+          return normalizeScore(this._score);
+        }
+        set ["score"](score) {
+          this._score = denormalizeScore(score);
+        }
+      }
+      var new_result = (target, options) => {
+        const result = new Result();
+        result["target"] = target;
+        result["obj"] = options.obj ?? NULL;
+        result._score = options._score ?? NEGATIVE_INFINITY;
+        result._indexes = options._indexes ?? [];
+        result._targetLower = options._targetLower ?? "";
+        result._targetLowerCodes = options._targetLowerCodes ?? NULL;
+        result._nextBeginningIndexes = options._nextBeginningIndexes ?? NULL;
+        result._bitflags = options._bitflags ?? 0;
+        return result;
+      };
+      var normalizeScore = (score) => {
+        if (score === NEGATIVE_INFINITY) return 0;
+        if (score > 1) return score;
+        return Math.E ** (((-score + 1) ** 0.04307 - 1) * -2);
+      };
+      var denormalizeScore = (normalizedScore) => {
+        if (normalizedScore === 0) return NEGATIVE_INFINITY;
+        if (normalizedScore > 1) return normalizedScore;
+        return 1 - Math.pow(Math.log(normalizedScore) / -2 + 1, 1 / 0.04307);
+      };
+      var prepareSearch = (search) => {
+        if (typeof search === "number") search = "" + search;
+        else if (typeof search !== "string") search = "";
+        search = search.trim();
+        var info = prepareLowerInfo(search);
+        var spaceSearches = [];
+        if (info.containsSpace) {
+          var searches = search.split(/\s+/);
+          searches = [...new Set(searches)];
+          for (var i = 0; i < searches.length; i++) {
+            if (searches[i] === "") continue;
+            var _info = prepareLowerInfo(searches[i]);
+            spaceSearches.push({ lowerCodes: _info.lowerCodes, _lower: searches[i].toLowerCase(), containsSpace: false });
+          }
+        }
+        return { lowerCodes: info.lowerCodes, _lower: info._lower, containsSpace: info.containsSpace, bitflags: info.bitflags, spaceSearches };
+      };
+      var getPrepared = (target) => {
+        if (target.length > 999) return prepare(target);
+        var targetPrepared = preparedCache.get(target);
+        if (targetPrepared !== void 0) return targetPrepared;
+        targetPrepared = prepare(target);
+        preparedCache.set(target, targetPrepared);
+        return targetPrepared;
+      };
+      var getPreparedSearch = (search) => {
+        if (search.length > 999) return prepareSearch(search);
+        var searchPrepared = preparedSearchCache.get(search);
+        if (searchPrepared !== void 0) return searchPrepared;
+        searchPrepared = prepareSearch(search);
+        preparedSearchCache.set(search, searchPrepared);
+        return searchPrepared;
+      };
+      var all = (targets, options) => {
+        var results = [];
+        results.total = targets.length;
+        var limit = options?.limit || INFINITY;
+        if (options?.key) {
+          for (var i = 0; i < targets.length; i++) {
+            var obj = targets[i];
+            var target = getValue(obj, options.key);
+            if (target == NULL) continue;
+            if (!isPrepared(target)) target = getPrepared(target);
+            var result = new_result(target.target, { _score: target._score, obj });
+            results.push(result);
+            if (results.length >= limit) return results;
+          }
+        } else if (options?.keys) {
+          for (var i = 0; i < targets.length; i++) {
+            var obj = targets[i];
+            var objResults = new KeysResult(options.keys.length);
+            for (var keyI = options.keys.length - 1; keyI >= 0; --keyI) {
+              var target = getValue(obj, options.keys[keyI]);
+              if (!target) {
+                objResults[keyI] = noTarget;
+                continue;
+              }
+              if (!isPrepared(target)) target = getPrepared(target);
+              target._score = NEGATIVE_INFINITY;
+              target._indexes.len = 0;
+              objResults[keyI] = target;
+            }
+            objResults.obj = obj;
+            objResults._score = NEGATIVE_INFINITY;
+            results.push(objResults);
+            if (results.length >= limit) return results;
+          }
+        } else {
+          for (var i = 0; i < targets.length; i++) {
+            var target = targets[i];
+            if (target == NULL) continue;
+            if (!isPrepared(target)) target = getPrepared(target);
+            target._score = NEGATIVE_INFINITY;
+            target._indexes.len = 0;
+            results.push(target);
+            if (results.length >= limit) return results;
+          }
+        }
+        return results;
+      };
+      var algorithm = (preparedSearch, prepared, allowSpaces = false, allowPartialMatch = false) => {
+        if (allowSpaces === false && preparedSearch.containsSpace) return algorithmSpaces(preparedSearch, prepared, allowPartialMatch);
+        var searchLower = preparedSearch._lower;
+        var searchLowerCodes = preparedSearch.lowerCodes;
+        var searchLowerCode = searchLowerCodes[0];
+        var targetLowerCodes = prepared._targetLowerCodes;
+        var searchLen = searchLowerCodes.length;
+        var targetLen = targetLowerCodes.length;
+        var searchI = 0;
+        var targetI = 0;
+        var matchesSimpleLen = 0;
+        for (; ; ) {
+          var isMatch = searchLowerCode === targetLowerCodes[targetI];
+          if (isMatch) {
+            matchesSimple[matchesSimpleLen++] = targetI;
+            ++searchI;
+            if (searchI === searchLen) break;
+            searchLowerCode = searchLowerCodes[searchI];
+          }
+          ++targetI;
+          if (targetI >= targetLen) return NULL;
+        }
+        var searchI = 0;
+        var successStrict = false;
+        var matchesStrictLen = 0;
+        var nextBeginningIndexes = prepared._nextBeginningIndexes;
+        if (nextBeginningIndexes === NULL) nextBeginningIndexes = prepared._nextBeginningIndexes = prepareNextBeginningIndexes(prepared.target);
+        targetI = matchesSimple[0] === 0 ? 0 : nextBeginningIndexes[matchesSimple[0] - 1];
+        var backtrackCount = 0;
+        if (targetI !== targetLen) for (; ; ) {
+          if (targetI >= targetLen) {
+            if (searchI <= 0) break;
+            ++backtrackCount;
+            if (backtrackCount > 200) break;
+            --searchI;
+            var lastMatch = matchesStrict[--matchesStrictLen];
+            targetI = nextBeginningIndexes[lastMatch];
+          } else {
+            var isMatch = searchLowerCodes[searchI] === targetLowerCodes[targetI];
+            if (isMatch) {
+              matchesStrict[matchesStrictLen++] = targetI;
+              ++searchI;
+              if (searchI === searchLen) {
+                successStrict = true;
+                break;
+              }
+              ++targetI;
+            } else {
+              targetI = nextBeginningIndexes[targetI];
+            }
+          }
+        }
+        var substringIndex = searchLen <= 1 ? -1 : prepared._targetLower.indexOf(searchLower, matchesSimple[0]);
+        var isSubstring = !!~substringIndex;
+        var isSubstringBeginning = !isSubstring ? false : substringIndex === 0 || prepared._nextBeginningIndexes[substringIndex - 1] === substringIndex;
+        if (isSubstring && !isSubstringBeginning) {
+          for (var i = 0; i < nextBeginningIndexes.length; i = nextBeginningIndexes[i]) {
+            if (i <= substringIndex) continue;
+            for (var s = 0; s < searchLen; s++) if (searchLowerCodes[s] !== prepared._targetLowerCodes[i + s]) break;
+            if (s === searchLen) {
+              substringIndex = i;
+              isSubstringBeginning = true;
+              break;
+            }
+          }
+        }
+        var calculateScore = (matches) => {
+          var score2 = 0;
+          var extraMatchGroupCount = 0;
+          for (var i2 = 1; i2 < searchLen; ++i2) {
+            if (matches[i2] - matches[i2 - 1] !== 1) {
+              score2 -= matches[i2];
+              ++extraMatchGroupCount;
+            }
+          }
+          var unmatchedDistance = matches[searchLen - 1] - matches[0] - (searchLen - 1);
+          score2 -= (12 + unmatchedDistance) * extraMatchGroupCount;
+          if (matches[0] !== 0) score2 -= matches[0] * matches[0] * 0.2;
+          if (!successStrict) {
+            score2 *= 1e3;
+          } else {
+            var uniqueBeginningIndexes = 1;
+            for (var i2 = nextBeginningIndexes[0]; i2 < targetLen; i2 = nextBeginningIndexes[i2]) ++uniqueBeginningIndexes;
+            if (uniqueBeginningIndexes > 24) score2 *= (uniqueBeginningIndexes - 24) * 10;
+          }
+          score2 -= (targetLen - searchLen) / 2;
+          if (isSubstring) score2 /= 1 + searchLen * searchLen * 1;
+          if (isSubstringBeginning) score2 /= 1 + searchLen * searchLen * 1;
+          score2 -= (targetLen - searchLen) / 2;
+          return score2;
+        };
+        if (!successStrict) {
+          if (isSubstring) for (var i = 0; i < searchLen; ++i) matchesSimple[i] = substringIndex + i;
+          var matchesBest = matchesSimple;
+          var score = calculateScore(matchesBest);
+        } else {
+          if (isSubstringBeginning) {
+            for (var i = 0; i < searchLen; ++i) matchesSimple[i] = substringIndex + i;
+            var matchesBest = matchesSimple;
+            var score = calculateScore(matchesSimple);
+          } else {
+            var matchesBest = matchesStrict;
+            var score = calculateScore(matchesStrict);
+          }
+        }
+        prepared._score = score;
+        for (var i = 0; i < searchLen; ++i) prepared._indexes[i] = matchesBest[i];
+        prepared._indexes.len = searchLen;
+        const result = new Result();
+        result.target = prepared.target;
+        result._score = prepared._score;
+        result._indexes = prepared._indexes;
+        return result;
+      };
+      var algorithmSpaces = (preparedSearch, target, allowPartialMatch) => {
+        var seen_indexes = /* @__PURE__ */ new Set();
+        var score = 0;
+        var result = NULL;
+        var first_seen_index_last_search = 0;
+        var searches = preparedSearch.spaceSearches;
+        var searchesLen = searches.length;
+        var changeslen = 0;
+        var resetNextBeginningIndexes = () => {
+          for (let i2 = changeslen - 1; i2 >= 0; i2--) target._nextBeginningIndexes[nextBeginningIndexesChanges[i2 * 2 + 0]] = nextBeginningIndexesChanges[i2 * 2 + 1];
+        };
+        var hasAtLeast1Match = false;
+        for (var i = 0; i < searchesLen; ++i) {
+          allowPartialMatchScores[i] = NEGATIVE_INFINITY;
+          var search = searches[i];
+          result = algorithm(search, target);
+          if (allowPartialMatch) {
+            if (result === NULL) continue;
+            hasAtLeast1Match = true;
+          } else {
+            if (result === NULL) {
+              resetNextBeginningIndexes();
+              return NULL;
+            }
+          }
+          var isTheLastSearch = i === searchesLen - 1;
+          if (!isTheLastSearch) {
+            var indexes = result._indexes;
+            var indexesIsConsecutiveSubstring = true;
+            for (let i2 = 0; i2 < indexes.len - 1; i2++) {
+              if (indexes[i2 + 1] - indexes[i2] !== 1) {
+                indexesIsConsecutiveSubstring = false;
+                break;
+              }
+            }
+            if (indexesIsConsecutiveSubstring) {
+              var newBeginningIndex = indexes[indexes.len - 1] + 1;
+              var toReplace = target._nextBeginningIndexes[newBeginningIndex - 1];
+              for (let i2 = newBeginningIndex - 1; i2 >= 0; i2--) {
+                if (toReplace !== target._nextBeginningIndexes[i2]) break;
+                target._nextBeginningIndexes[i2] = newBeginningIndex;
+                nextBeginningIndexesChanges[changeslen * 2 + 0] = i2;
+                nextBeginningIndexesChanges[changeslen * 2 + 1] = toReplace;
+                changeslen++;
+              }
+            }
+          }
+          score += result._score / searchesLen;
+          allowPartialMatchScores[i] = result._score / searchesLen;
+          if (result._indexes[0] < first_seen_index_last_search) {
+            score -= (first_seen_index_last_search - result._indexes[0]) * 2;
+          }
+          first_seen_index_last_search = result._indexes[0];
+          for (var j3 = 0; j3 < result._indexes.len; ++j3) seen_indexes.add(result._indexes[j3]);
+        }
+        if (allowPartialMatch && !hasAtLeast1Match) return NULL;
+        resetNextBeginningIndexes();
+        var allowSpacesResult = algorithm(
+          preparedSearch,
+          target,
+          /*allowSpaces=*/
+          true
+        );
+        if (allowSpacesResult !== NULL && allowSpacesResult._score > score) {
+          if (allowPartialMatch) {
+            for (var i = 0; i < searchesLen; ++i) {
+              allowPartialMatchScores[i] = allowSpacesResult._score / searchesLen;
+            }
+          }
+          return allowSpacesResult;
+        }
+        if (allowPartialMatch) result = target;
+        result._score = score;
+        var i = 0;
+        for (let index of seen_indexes) result._indexes[i++] = index;
+        result._indexes.len = i;
+        return result;
+      };
+      var remove_accents = (str) => str.replace(/\p{Script=Latin}+/gu, (match) => match.normalize("NFD")).replace(/[\u0300-\u036f]/g, "");
+      var prepareLowerInfo = (str) => {
+        str = remove_accents(str);
+        var strLen = str.length;
+        var lower = str.toLowerCase();
+        var lowerCodes = [];
+        var bitflags = 0;
+        var containsSpace = false;
+        for (var i = 0; i < strLen; ++i) {
+          var lowerCode = lowerCodes[i] = lower.charCodeAt(i);
+          if (lowerCode === 32) {
+            containsSpace = true;
+            continue;
+          }
+          var bit = lowerCode >= 97 && lowerCode <= 122 ? lowerCode - 97 : lowerCode >= 48 && lowerCode <= 57 ? 26 : lowerCode <= 127 ? 30 : 31;
+          bitflags |= 1 << bit;
+        }
+        return { lowerCodes, bitflags, containsSpace, _lower: lower };
+      };
+      var prepareBeginningIndexes = (target) => {
+        var targetLen = target.length;
+        var beginningIndexes = [];
+        var beginningIndexesLen = 0;
+        var wasUpper = false;
+        var wasAlphanum = false;
+        for (var i = 0; i < targetLen; ++i) {
+          var targetCode = target.charCodeAt(i);
+          var isUpper = targetCode >= 65 && targetCode <= 90;
+          var isAlphanum = isUpper || targetCode >= 97 && targetCode <= 122 || targetCode >= 48 && targetCode <= 57;
+          var isBeginning = isUpper && !wasUpper || !wasAlphanum || !isAlphanum;
+          wasUpper = isUpper;
+          wasAlphanum = isAlphanum;
+          if (isBeginning) beginningIndexes[beginningIndexesLen++] = i;
+        }
+        return beginningIndexes;
+      };
+      var prepareNextBeginningIndexes = (target) => {
+        target = remove_accents(target);
+        var targetLen = target.length;
+        var beginningIndexes = prepareBeginningIndexes(target);
+        var nextBeginningIndexes = [];
+        var lastIsBeginning = beginningIndexes[0];
+        var lastIsBeginningI = 0;
+        for (var i = 0; i < targetLen; ++i) {
+          if (lastIsBeginning > i) {
+            nextBeginningIndexes[i] = lastIsBeginning;
+          } else {
+            lastIsBeginning = beginningIndexes[++lastIsBeginningI];
+            nextBeginningIndexes[i] = lastIsBeginning === void 0 ? targetLen : lastIsBeginning;
+          }
+        }
+        return nextBeginningIndexes;
+      };
+      var preparedCache = /* @__PURE__ */ new Map();
+      var preparedSearchCache = /* @__PURE__ */ new Map();
+      var matchesSimple = [];
+      var matchesStrict = [];
+      var nextBeginningIndexesChanges = [];
+      var keysSpacesBestScores = [];
+      var allowPartialMatchScores = [];
+      var tmpTargets = [];
+      var tmpResults = [];
+      var getValue = (obj, prop) => {
+        var tmp = obj[prop];
+        if (tmp !== void 0) return tmp;
+        if (typeof prop === "function") return prop(obj);
+        var segs = prop;
+        if (!Array.isArray(prop)) segs = prop.split(".");
+        var len = segs.length;
+        var i = -1;
+        while (obj && ++i < len) obj = obj[segs[i]];
+        return obj;
+      };
+      var isPrepared = (x) => {
+        return typeof x === "object" && typeof x._bitflags === "number";
+      };
+      var INFINITY = Infinity;
+      var NEGATIVE_INFINITY = -INFINITY;
+      var noResults = [];
+      noResults.total = 0;
+      var NULL = null;
+      var noTarget = prepare("");
+      var fastpriorityqueue = (r) => {
+        var e = [], o = 0, a = {}, v2 = (r2) => {
+          for (var a2 = 0, v3 = e[a2], c = 1; c < o; ) {
+            var s = c + 1;
+            a2 = c, s < o && e[s]._score < e[c]._score && (a2 = s), e[a2 - 1 >> 1] = e[a2], c = 1 + (a2 << 1);
+          }
+          for (var f = a2 - 1 >> 1; a2 > 0 && v3._score < e[f]._score; f = (a2 = f) - 1 >> 1) e[a2] = e[f];
+          e[a2] = v3;
+        };
+        return a.add = ((r2) => {
+          var a2 = o;
+          e[o++] = r2;
+          for (var v3 = a2 - 1 >> 1; a2 > 0 && r2._score < e[v3]._score; v3 = (a2 = v3) - 1 >> 1) e[a2] = e[v3];
+          e[a2] = r2;
+        }), a.poll = ((r2) => {
+          if (0 !== o) {
+            var a2 = e[0];
+            return e[0] = e[--o], v2(), a2;
+          }
+        }), a.peek = ((r2) => {
+          if (0 !== o) return e[0];
+        }), a.replaceTop = ((r2) => {
+          e[0] = r2, v2();
+        }), a;
+      };
+      var q3 = fastpriorityqueue();
+      return { "single": single, "go": go2, "prepare": prepare, "cleanup": cleanup };
+    });
+  }
+});
+
+// ../list/dist/index.js
+init_live_reload();
+
+// ../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+init_live_reload();
+
+// ../../node_modules/@vue/shared/dist/shared.esm-bundler.js
+init_live_reload();
+// @__NO_SIDE_EFFECTS__
+function makeMap(str) {
+  const map = /* @__PURE__ */ Object.create(null);
+  for (const key of str.split(",")) map[key] = 1;
+  return (val) => val in map;
+}
+var EMPTY_OBJ = true ? Object.freeze({}) : {};
+var EMPTY_ARR = true ? Object.freeze([]) : [];
+var NOOP = () => {
+};
+var extend = Object.assign;
+var remove = (arr, el) => {
+  const i = arr.indexOf(el);
+  if (i > -1) {
+    arr.splice(i, 1);
+  }
+};
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var hasOwn = (val, key) => hasOwnProperty.call(val, key);
+var isArray = Array.isArray;
+var isMap = (val) => toTypeString(val) === "[object Map]";
+var isSet = (val) => toTypeString(val) === "[object Set]";
+var isFunction = (val) => typeof val === "function";
+var isString = (val) => typeof val === "string";
+var isSymbol = (val) => typeof val === "symbol";
+var isObject = (val) => val !== null && typeof val === "object";
+var objectToString = Object.prototype.toString;
+var toTypeString = (value) => objectToString.call(value);
+var toRawType = (value) => {
+  return toTypeString(value).slice(8, -1);
+};
+var isPlainObject = (val) => toTypeString(val) === "[object Object]";
+var isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+var cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return ((str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  });
+};
+var camelizeRE = /-\w/g;
+var camelize = cacheStringFunction(
+  (str) => {
+    return str.replace(camelizeRE, (c) => c.slice(1).toUpperCase());
+  }
+);
+var hyphenateRE = /\B([A-Z])/g;
+var hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+var capitalize = cacheStringFunction((str) => {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+});
+var toHandlerKey = cacheStringFunction(
+  (str) => {
+    const s = str ? `on${capitalize(str)}` : ``;
+    return s;
+  }
+);
+var hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+var specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+var isBooleanAttr = /* @__PURE__ */ makeMap(
+  specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+);
+
+// ../../node_modules/@vue/reactivity/dist/reactivity.esm-bundler.js
+function warn(msg, ...args) {
+  console.warn(`[Vue warn] ${msg}`, ...args);
+}
+var activeEffectScope;
+function getCurrentScope() {
+  return activeEffectScope;
+}
+var activeSub;
+var pausedQueueEffects = /* @__PURE__ */ new WeakSet();
+var ReactiveEffect = class {
+  constructor(fn) {
+    this.fn = fn;
+    this.deps = void 0;
+    this.depsTail = void 0;
+    this.flags = 1 | 4;
+    this.next = void 0;
+    this.cleanup = void 0;
+    this.scheduler = void 0;
+    if (activeEffectScope && activeEffectScope.active) {
+      activeEffectScope.effects.push(this);
+    }
+  }
+  pause() {
+    this.flags |= 64;
+  }
+  resume() {
+    if (this.flags & 64) {
+      this.flags &= -65;
+      if (pausedQueueEffects.has(this)) {
+        pausedQueueEffects.delete(this);
+        this.trigger();
+      }
+    }
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    if (this.flags & 2 && !(this.flags & 32)) {
+      return;
+    }
+    if (!(this.flags & 8)) {
+      batch(this);
+    }
+  }
+  run() {
+    if (!(this.flags & 1)) {
+      return this.fn();
+    }
+    this.flags |= 2;
+    cleanupEffect(this);
+    prepareDeps(this);
+    const prevEffect = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = this;
+    shouldTrack = true;
+    try {
+      return this.fn();
+    } finally {
+      if (activeSub !== this) {
+        warn(
+          "Active effect was not restored correctly - this is likely a Vue internal bug."
+        );
+      }
+      cleanupDeps(this);
+      activeSub = prevEffect;
+      shouldTrack = prevShouldTrack;
+      this.flags &= -3;
+    }
+  }
+  stop() {
+    if (this.flags & 1) {
+      for (let link = this.deps; link; link = link.nextDep) {
+        removeSub(link);
+      }
+      this.deps = this.depsTail = void 0;
+      cleanupEffect(this);
+      this.onStop && this.onStop();
+      this.flags &= -2;
+    }
+  }
+  trigger() {
+    if (this.flags & 64) {
+      pausedQueueEffects.add(this);
+    } else if (this.scheduler) {
+      this.scheduler();
+    } else {
+      this.runIfDirty();
+    }
+  }
+  /**
+   * @internal
+   */
+  runIfDirty() {
+    if (isDirty(this)) {
+      this.run();
+    }
+  }
+  get dirty() {
+    return isDirty(this);
+  }
+};
+var batchDepth = 0;
+var batchedSub;
+var batchedComputed;
+function batch(sub, isComputed = false) {
+  sub.flags |= 8;
+  if (isComputed) {
+    sub.next = batchedComputed;
+    batchedComputed = sub;
+    return;
+  }
+  sub.next = batchedSub;
+  batchedSub = sub;
+}
+function startBatch() {
+  batchDepth++;
+}
+function endBatch() {
+  if (--batchDepth > 0) {
+    return;
+  }
+  if (batchedComputed) {
+    let e = batchedComputed;
+    batchedComputed = void 0;
+    while (e) {
+      const next = e.next;
+      e.next = void 0;
+      e.flags &= -9;
+      e = next;
+    }
+  }
+  let error;
+  while (batchedSub) {
+    let e = batchedSub;
+    batchedSub = void 0;
+    while (e) {
+      const next = e.next;
+      e.next = void 0;
+      e.flags &= -9;
+      if (e.flags & 1) {
+        try {
+          ;
+          e.trigger();
+        } catch (err) {
+          if (!error) error = err;
+        }
+      }
+      e = next;
+    }
+  }
+  if (error) throw error;
+}
+function prepareDeps(sub) {
+  for (let link = sub.deps; link; link = link.nextDep) {
+    link.version = -1;
+    link.prevActiveLink = link.dep.activeLink;
+    link.dep.activeLink = link;
+  }
+}
+function cleanupDeps(sub) {
+  let head;
+  let tail = sub.depsTail;
+  let link = tail;
+  while (link) {
+    const prev = link.prevDep;
+    if (link.version === -1) {
+      if (link === tail) tail = prev;
+      removeSub(link);
+      removeDep(link);
+    } else {
+      head = link;
+    }
+    link.dep.activeLink = link.prevActiveLink;
+    link.prevActiveLink = void 0;
+    link = prev;
+  }
+  sub.deps = head;
+  sub.depsTail = tail;
+}
+function isDirty(sub) {
+  for (let link = sub.deps; link; link = link.nextDep) {
+    if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
+      return true;
+    }
+  }
+  if (sub._dirty) {
+    return true;
+  }
+  return false;
+}
+function refreshComputed(computed2) {
+  if (computed2.flags & 4 && !(computed2.flags & 16)) {
+    return;
+  }
+  computed2.flags &= -17;
+  if (computed2.globalVersion === globalVersion) {
+    return;
+  }
+  computed2.globalVersion = globalVersion;
+  if (!computed2.isSSR && computed2.flags & 128 && (!computed2.deps && !computed2._dirty || !isDirty(computed2))) {
+    return;
+  }
+  computed2.flags |= 2;
+  const dep = computed2.dep;
+  const prevSub = activeSub;
+  const prevShouldTrack = shouldTrack;
+  activeSub = computed2;
+  shouldTrack = true;
+  try {
+    prepareDeps(computed2);
+    const value = computed2.fn(computed2._value);
+    if (dep.version === 0 || hasChanged(value, computed2._value)) {
+      computed2.flags |= 128;
+      computed2._value = value;
+      dep.version++;
+    }
+  } catch (err) {
+    dep.version++;
+    throw err;
+  } finally {
+    activeSub = prevSub;
+    shouldTrack = prevShouldTrack;
+    cleanupDeps(computed2);
+    computed2.flags &= -3;
+  }
+}
+function removeSub(link, soft = false) {
+  const { dep, prevSub, nextSub } = link;
+  if (prevSub) {
+    prevSub.nextSub = nextSub;
+    link.prevSub = void 0;
+  }
+  if (nextSub) {
+    nextSub.prevSub = prevSub;
+    link.nextSub = void 0;
+  }
+  if (dep.subsHead === link) {
+    dep.subsHead = nextSub;
+  }
+  if (dep.subs === link) {
+    dep.subs = prevSub;
+    if (!prevSub && dep.computed) {
+      dep.computed.flags &= -5;
+      for (let l = dep.computed.deps; l; l = l.nextDep) {
+        removeSub(l, true);
+      }
+    }
+  }
+  if (!soft && !--dep.sc && dep.map) {
+    dep.map.delete(dep.key);
+  }
+}
+function removeDep(link) {
+  const { prevDep, nextDep } = link;
+  if (prevDep) {
+    prevDep.nextDep = nextDep;
+    link.prevDep = void 0;
+  }
+  if (nextDep) {
+    nextDep.prevDep = prevDep;
+    link.nextDep = void 0;
+  }
+}
+function effect(fn, options) {
+  if (fn.effect instanceof ReactiveEffect) {
+    fn = fn.effect.fn;
+  }
+  const e = new ReactiveEffect(fn);
+  if (options) {
+    extend(e, options);
+  }
+  try {
+    e.run();
+  } catch (err) {
+    e.stop();
+    throw err;
+  }
+  const runner = e.run.bind(e);
+  runner.effect = e;
+  return runner;
+}
+var shouldTrack = true;
+var trackStack = [];
+function pauseTracking() {
+  trackStack.push(shouldTrack);
+  shouldTrack = false;
+}
+function resetTracking() {
+  const last = trackStack.pop();
+  shouldTrack = last === void 0 ? true : last;
+}
+function cleanupEffect(e) {
+  const { cleanup } = e;
+  e.cleanup = void 0;
+  if (cleanup) {
+    const prevSub = activeSub;
+    activeSub = void 0;
+    try {
+      cleanup();
+    } finally {
+      activeSub = prevSub;
+    }
+  }
+}
+var globalVersion = 0;
+var Link = class {
+  constructor(sub, dep) {
+    this.sub = sub;
+    this.dep = dep;
+    this.version = dep.version;
+    this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+  }
+};
+var Dep = class {
+  // TODO isolatedDeclarations "__v_skip"
+  constructor(computed2) {
+    this.computed = computed2;
+    this.version = 0;
+    this.activeLink = void 0;
+    this.subs = void 0;
+    this.map = void 0;
+    this.key = void 0;
+    this.sc = 0;
+    this.__v_skip = true;
+    if (true) {
+      this.subsHead = void 0;
+    }
+  }
+  track(debugInfo) {
+    if (!activeSub || !shouldTrack || activeSub === this.computed) {
+      return;
+    }
+    let link = this.activeLink;
+    if (link === void 0 || link.sub !== activeSub) {
+      link = this.activeLink = new Link(activeSub, this);
+      if (!activeSub.deps) {
+        activeSub.deps = activeSub.depsTail = link;
+      } else {
+        link.prevDep = activeSub.depsTail;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+      }
+      addSub(link);
+    } else if (link.version === -1) {
+      link.version = this.version;
+      if (link.nextDep) {
+        const next = link.nextDep;
+        next.prevDep = link.prevDep;
+        if (link.prevDep) {
+          link.prevDep.nextDep = next;
+        }
+        link.prevDep = activeSub.depsTail;
+        link.nextDep = void 0;
+        activeSub.depsTail.nextDep = link;
+        activeSub.depsTail = link;
+        if (activeSub.deps === link) {
+          activeSub.deps = next;
+        }
+      }
+    }
+    if (activeSub.onTrack) {
+      activeSub.onTrack(
+        extend(
+          {
+            effect: activeSub
+          },
+          debugInfo
+        )
+      );
+    }
+    return link;
+  }
+  trigger(debugInfo) {
+    this.version++;
+    globalVersion++;
+    this.notify(debugInfo);
+  }
+  notify(debugInfo) {
+    startBatch();
+    try {
+      if (true) {
+        for (let head = this.subsHead; head; head = head.nextSub) {
+          if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+            head.sub.onTrigger(
+              extend(
+                {
+                  effect: head.sub
+                },
+                debugInfo
+              )
+            );
+          }
+        }
+      }
+      for (let link = this.subs; link; link = link.prevSub) {
+        if (link.sub.notify()) {
+          ;
+          link.sub.dep.notify();
+        }
+      }
+    } finally {
+      endBatch();
+    }
+  }
+};
+function addSub(link) {
+  link.dep.sc++;
+  if (link.sub.flags & 4) {
+    const computed2 = link.dep.computed;
+    if (computed2 && !link.dep.subs) {
+      computed2.flags |= 4 | 16;
+      for (let l = computed2.deps; l; l = l.nextDep) {
+        addSub(l);
+      }
+    }
+    const currentTail = link.dep.subs;
+    if (currentTail !== link) {
+      link.prevSub = currentTail;
+      if (currentTail) currentTail.nextSub = link;
+    }
+    if (link.dep.subsHead === void 0) {
+      link.dep.subsHead = link;
+    }
+    link.dep.subs = link;
+  }
+}
+var targetMap = /* @__PURE__ */ new WeakMap();
+var ITERATE_KEY = /* @__PURE__ */ Symbol(
+  true ? "Object iterate" : ""
+);
+var MAP_KEY_ITERATE_KEY = /* @__PURE__ */ Symbol(
+  true ? "Map keys iterate" : ""
+);
+var ARRAY_ITERATE_KEY = /* @__PURE__ */ Symbol(
+  true ? "Array iterate" : ""
+);
+function track(target, type, key) {
+  if (shouldTrack && activeSub) {
+    let depsMap = targetMap.get(target);
+    if (!depsMap) {
+      targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+    }
+    let dep = depsMap.get(key);
+    if (!dep) {
+      depsMap.set(key, dep = new Dep());
+      dep.map = depsMap;
+      dep.key = key;
+    }
+    if (true) {
+      dep.track({
+        target,
+        type,
+        key
+      });
+    } else {
+      dep.track();
+    }
+  }
+}
+function trigger(target, type, key, newValue, oldValue, oldTarget) {
+  const depsMap = targetMap.get(target);
+  if (!depsMap) {
+    globalVersion++;
+    return;
+  }
+  const run = (dep) => {
+    if (dep) {
+      if (true) {
+        dep.trigger({
+          target,
+          type,
+          key,
+          newValue,
+          oldValue,
+          oldTarget
+        });
+      } else {
+        dep.trigger();
+      }
+    }
+  };
+  startBatch();
+  if (type === "clear") {
+    depsMap.forEach(run);
+  } else {
+    const targetIsArray = isArray(target);
+    const isArrayIndex = targetIsArray && isIntegerKey(key);
+    if (targetIsArray && key === "length") {
+      const newLength = Number(newValue);
+      depsMap.forEach((dep, key2) => {
+        if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+          run(dep);
+        }
+      });
+    } else {
+      if (key !== void 0 || depsMap.has(void 0)) {
+        run(depsMap.get(key));
+      }
+      if (isArrayIndex) {
+        run(depsMap.get(ARRAY_ITERATE_KEY));
+      }
+      switch (type) {
+        case "add":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          } else if (isArrayIndex) {
+            run(depsMap.get("length"));
+          }
+          break;
+        case "delete":
+          if (!targetIsArray) {
+            run(depsMap.get(ITERATE_KEY));
+            if (isMap(target)) {
+              run(depsMap.get(MAP_KEY_ITERATE_KEY));
+            }
+          }
+          break;
+        case "set":
+          if (isMap(target)) {
+            run(depsMap.get(ITERATE_KEY));
+          }
+          break;
+      }
+    }
+  }
+  endBatch();
+}
+function reactiveReadArray(array) {
+  const raw = /* @__PURE__ */ toRaw(array);
+  if (raw === array) return raw;
+  track(raw, "iterate", ARRAY_ITERATE_KEY);
+  return /* @__PURE__ */ isShallow(array) ? raw : raw.map(toReactive);
+}
+function shallowReadArray(arr) {
+  track(arr = /* @__PURE__ */ toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+  return arr;
+}
+function toWrapped(target, item) {
+  if (/* @__PURE__ */ isReadonly(target)) {
+    return /* @__PURE__ */ isReactive(target) ? toReadonly(toReactive(item)) : toReadonly(item);
+  }
+  return toReactive(item);
+}
+var arrayInstrumentations = {
+  __proto__: null,
+  [Symbol.iterator]() {
+    return iterator(this, Symbol.iterator, (item) => toWrapped(this, item));
+  },
+  concat(...args) {
+    return reactiveReadArray(this).concat(
+      ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
+    );
+  },
+  entries() {
+    return iterator(this, "entries", (value) => {
+      value[1] = toWrapped(this, value[1]);
+      return value;
+    });
+  },
+  every(fn, thisArg) {
+    return apply(this, "every", fn, thisArg, void 0, arguments);
+  },
+  filter(fn, thisArg) {
+    return apply(
+      this,
+      "filter",
+      fn,
+      thisArg,
+      (v2) => v2.map((item) => toWrapped(this, item)),
+      arguments
+    );
+  },
+  find(fn, thisArg) {
+    return apply(
+      this,
+      "find",
+      fn,
+      thisArg,
+      (item) => toWrapped(this, item),
+      arguments
+    );
+  },
+  findIndex(fn, thisArg) {
+    return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+  },
+  findLast(fn, thisArg) {
+    return apply(
+      this,
+      "findLast",
+      fn,
+      thisArg,
+      (item) => toWrapped(this, item),
+      arguments
+    );
+  },
+  findLastIndex(fn, thisArg) {
+    return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+  },
+  // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+  forEach(fn, thisArg) {
+    return apply(this, "forEach", fn, thisArg, void 0, arguments);
+  },
+  includes(...args) {
+    return searchProxy(this, "includes", args);
+  },
+  indexOf(...args) {
+    return searchProxy(this, "indexOf", args);
+  },
+  join(separator) {
+    return reactiveReadArray(this).join(separator);
+  },
+  // keys() iterator only reads `length`, no optimization required
+  lastIndexOf(...args) {
+    return searchProxy(this, "lastIndexOf", args);
+  },
+  map(fn, thisArg) {
+    return apply(this, "map", fn, thisArg, void 0, arguments);
+  },
+  pop() {
+    return noTracking(this, "pop");
+  },
+  push(...args) {
+    return noTracking(this, "push", args);
+  },
+  reduce(fn, ...args) {
+    return reduce(this, "reduce", fn, args);
+  },
+  reduceRight(fn, ...args) {
+    return reduce(this, "reduceRight", fn, args);
+  },
+  shift() {
+    return noTracking(this, "shift");
+  },
+  // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+  some(fn, thisArg) {
+    return apply(this, "some", fn, thisArg, void 0, arguments);
+  },
+  splice(...args) {
+    return noTracking(this, "splice", args);
+  },
+  toReversed() {
+    return reactiveReadArray(this).toReversed();
+  },
+  toSorted(comparer) {
+    return reactiveReadArray(this).toSorted(comparer);
+  },
+  toSpliced(...args) {
+    return reactiveReadArray(this).toSpliced(...args);
+  },
+  unshift(...args) {
+    return noTracking(this, "unshift", args);
+  },
+  values() {
+    return iterator(this, "values", (item) => toWrapped(this, item));
+  }
+};
+function iterator(self2, method, wrapValue) {
+  const arr = shallowReadArray(self2);
+  const iter = arr[method]();
+  if (arr !== self2 && !/* @__PURE__ */ isShallow(self2)) {
+    iter._next = iter.next;
+    iter.next = () => {
+      const result = iter._next();
+      if (!result.done) {
+        result.value = wrapValue(result.value);
+      }
+      return result;
+    };
+  }
+  return iter;
+}
+var arrayProto = Array.prototype;
+function apply(self2, method, fn, thisArg, wrappedRetFn, args) {
+  const arr = shallowReadArray(self2);
+  const needsWrap = arr !== self2 && !/* @__PURE__ */ isShallow(self2);
+  const methodFn = arr[method];
+  if (methodFn !== arrayProto[method]) {
+    const result2 = methodFn.apply(self2, args);
+    return needsWrap ? toReactive(result2) : result2;
+  }
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (needsWrap) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 2) {
+      wrappedFn = function(item, index) {
+        return fn.call(this, item, index, self2);
+      };
+    }
+  }
+  const result = methodFn.call(arr, wrappedFn, thisArg);
+  return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
+}
+function reduce(self2, method, fn, args) {
+  const arr = shallowReadArray(self2);
+  let wrappedFn = fn;
+  if (arr !== self2) {
+    if (!/* @__PURE__ */ isShallow(self2)) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, toWrapped(self2, item), index, self2);
+      };
+    } else if (fn.length > 3) {
+      wrappedFn = function(acc, item, index) {
+        return fn.call(this, acc, item, index, self2);
+      };
+    }
+  }
+  return arr[method](wrappedFn, ...args);
+}
+function searchProxy(self2, method, args) {
+  const arr = /* @__PURE__ */ toRaw(self2);
+  track(arr, "iterate", ARRAY_ITERATE_KEY);
+  const res = arr[method](...args);
+  if ((res === -1 || res === false) && /* @__PURE__ */ isProxy(args[0])) {
+    args[0] = /* @__PURE__ */ toRaw(args[0]);
+    return arr[method](...args);
+  }
+  return res;
+}
+function noTracking(self2, method, args = []) {
+  pauseTracking();
+  startBatch();
+  const res = (/* @__PURE__ */ toRaw(self2))[method].apply(self2, args);
+  endBatch();
+  resetTracking();
+  return res;
+}
+var isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+var builtInSymbols = new Set(
+  /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+);
+function hasOwnProperty2(key) {
+  if (!isSymbol(key)) key = String(key);
+  const obj = /* @__PURE__ */ toRaw(this);
+  track(obj, "has", key);
+  return obj.hasOwnProperty(key);
+}
+var BaseReactiveHandler = class {
+  constructor(_isReadonly = false, _isShallow = false) {
+    this._isReadonly = _isReadonly;
+    this._isShallow = _isShallow;
+  }
+  get(target, key, receiver) {
+    if (key === "__v_skip") return target["__v_skip"];
+    const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_isShallow") {
+      return isShallow2;
+    } else if (key === "__v_raw") {
+      if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
+      // this means the receiver is a user proxy of the reactive proxy
+      Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+        return target;
+      }
+      return;
+    }
+    const targetIsArray = isArray(target);
+    if (!isReadonly2) {
+      let fn;
+      if (targetIsArray && (fn = arrayInstrumentations[key])) {
+        return fn;
+      }
+      if (key === "hasOwnProperty") {
+        return hasOwnProperty2;
+      }
+    }
+    const res = Reflect.get(
+      target,
+      key,
+      // if this is a proxy wrapping a ref, return methods using the raw ref
+      // as receiver so that we don't have to call `toRaw` on the ref in all
+      // its class methods
+      /* @__PURE__ */ isRef(target) ? target : receiver
+    );
+    if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+      return res;
+    }
+    if (!isReadonly2) {
+      track(target, "get", key);
+    }
+    if (isShallow2) {
+      return res;
+    }
+    if (/* @__PURE__ */ isRef(res)) {
+      const value = targetIsArray && isIntegerKey(key) ? res : res.value;
+      return isReadonly2 && isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+    }
+    if (isObject(res)) {
+      return isReadonly2 ? /* @__PURE__ */ readonly(res) : /* @__PURE__ */ reactive(res);
+    }
+    return res;
+  }
+};
+var MutableReactiveHandler = class extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(false, isShallow2);
+  }
+  set(target, key, value, receiver) {
+    let oldValue = target[key];
+    const isArrayWithIntegerKey = isArray(target) && isIntegerKey(key);
+    if (!this._isShallow) {
+      const isOldValueReadonly = /* @__PURE__ */ isReadonly(oldValue);
+      if (!/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
+        oldValue = /* @__PURE__ */ toRaw(oldValue);
+        value = /* @__PURE__ */ toRaw(value);
+      }
+      if (!isArrayWithIntegerKey && /* @__PURE__ */ isRef(oldValue) && !/* @__PURE__ */ isRef(value)) {
+        if (isOldValueReadonly) {
+          if (true) {
+            warn(
+              `Set operation on key "${String(key)}" failed: target is readonly.`,
+              target[key]
+            );
+          }
+          return true;
+        } else {
+          oldValue.value = value;
+          return true;
+        }
+      }
+    }
+    const hadKey = isArrayWithIntegerKey ? Number(key) < target.length : hasOwn(target, key);
+    const result = Reflect.set(
+      target,
+      key,
+      value,
+      /* @__PURE__ */ isRef(target) ? target : receiver
+    );
+    if (target === /* @__PURE__ */ toRaw(receiver)) {
+      if (!hadKey) {
+        trigger(target, "add", key, value);
+      } else if (hasChanged(value, oldValue)) {
+        trigger(target, "set", key, value, oldValue);
+      }
+    }
+    return result;
+  }
+  deleteProperty(target, key) {
+    const hadKey = hasOwn(target, key);
+    const oldValue = target[key];
+    const result = Reflect.deleteProperty(target, key);
+    if (result && hadKey) {
+      trigger(target, "delete", key, void 0, oldValue);
+    }
+    return result;
+  }
+  has(target, key) {
+    const result = Reflect.has(target, key);
+    if (!isSymbol(key) || !builtInSymbols.has(key)) {
+      track(target, "has", key);
+    }
+    return result;
+  }
+  ownKeys(target) {
+    track(
+      target,
+      "iterate",
+      isArray(target) ? "length" : ITERATE_KEY
+    );
+    return Reflect.ownKeys(target);
+  }
+};
+var ReadonlyReactiveHandler = class extends BaseReactiveHandler {
+  constructor(isShallow2 = false) {
+    super(true, isShallow2);
+  }
+  set(target, key) {
+    if (true) {
+      warn(
+        `Set operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+  deleteProperty(target, key) {
+    if (true) {
+      warn(
+        `Delete operation on key "${String(key)}" failed: target is readonly.`,
+        target
+      );
+    }
+    return true;
+  }
+};
+var mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+var readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+var toShallow = (value) => value;
+var getProto = (v2) => Reflect.getPrototypeOf(v2);
+function createIterableMethod(method, isReadonly2, isShallow2) {
+  return function(...args) {
+    const target = this["__v_raw"];
+    const rawTarget = /* @__PURE__ */ toRaw(target);
+    const targetIsMap = isMap(rawTarget);
+    const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+    const isKeyOnly = method === "keys" && targetIsMap;
+    const innerIterator = target[method](...args);
+    const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+    !isReadonly2 && track(
+      rawTarget,
+      "iterate",
+      isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+    );
+    return extend(
+      // inheriting all iterator properties
+      Object.create(innerIterator),
+      {
+        // iterator protocol
+        next() {
+          const { value, done } = innerIterator.next();
+          return done ? { value, done } : {
+            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+            done
+          };
+        }
+      }
+    );
+  };
+}
+function createReadonlyMethod(type) {
+  return function(...args) {
+    if (true) {
+      const key = args[0] ? `on key "${args[0]}" ` : ``;
+      warn(
+        `${capitalize(type)} operation ${key}failed: target is readonly.`,
+        /* @__PURE__ */ toRaw(this)
+      );
+    }
+    return type === "delete" ? false : type === "clear" ? void 0 : this;
+  };
+}
+function createInstrumentations(readonly2, shallow) {
+  const instrumentations = {
+    get(key) {
+      const target = this["__v_raw"];
+      const rawTarget = /* @__PURE__ */ toRaw(target);
+      const rawKey = /* @__PURE__ */ toRaw(key);
+      if (!readonly2) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "get", key);
+        }
+        track(rawTarget, "get", rawKey);
+      }
+      const { has } = getProto(rawTarget);
+      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
+      if (has.call(rawTarget, key)) {
+        return wrap(target.get(key));
+      } else if (has.call(rawTarget, rawKey)) {
+        return wrap(target.get(rawKey));
+      } else if (target !== rawTarget) {
+        target.get(key);
+      }
+    },
+    get size() {
+      const target = this["__v_raw"];
+      !readonly2 && track(/* @__PURE__ */ toRaw(target), "iterate", ITERATE_KEY);
+      return target.size;
+    },
+    has(key) {
+      const target = this["__v_raw"];
+      const rawTarget = /* @__PURE__ */ toRaw(target);
+      const rawKey = /* @__PURE__ */ toRaw(key);
+      if (!readonly2) {
+        if (hasChanged(key, rawKey)) {
+          track(rawTarget, "has", key);
+        }
+        track(rawTarget, "has", rawKey);
+      }
+      return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+    },
+    forEach(callback, thisArg) {
+      const observed = this;
+      const target = observed["__v_raw"];
+      const rawTarget = /* @__PURE__ */ toRaw(target);
+      const wrap = shallow ? toShallow : readonly2 ? toReadonly : toReactive;
+      !readonly2 && track(rawTarget, "iterate", ITERATE_KEY);
+      return target.forEach((value, key) => {
+        return callback.call(thisArg, wrap(value), wrap(key), observed);
+      });
+    }
+  };
+  extend(
+    instrumentations,
+    readonly2 ? {
+      add: createReadonlyMethod("add"),
+      set: createReadonlyMethod("set"),
+      delete: createReadonlyMethod("delete"),
+      clear: createReadonlyMethod("clear")
+    } : {
+      add(value) {
+        if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
+          value = /* @__PURE__ */ toRaw(value);
+        }
+        const target = /* @__PURE__ */ toRaw(this);
+        const proto = getProto(target);
+        const hadKey = proto.has.call(target, value);
+        if (!hadKey) {
+          target.add(value);
+          trigger(target, "add", value, value);
+        }
+        return this;
+      },
+      set(key, value) {
+        if (!shallow && !/* @__PURE__ */ isShallow(value) && !/* @__PURE__ */ isReadonly(value)) {
+          value = /* @__PURE__ */ toRaw(value);
+        }
+        const target = /* @__PURE__ */ toRaw(this);
+        const { has, get } = getProto(target);
+        let hadKey = has.call(target, key);
+        if (!hadKey) {
+          key = /* @__PURE__ */ toRaw(key);
+          hadKey = has.call(target, key);
+        } else if (true) {
+          checkIdentityKeys(target, has, key);
+        }
+        const oldValue = get.call(target, key);
+        target.set(key, value);
+        if (!hadKey) {
+          trigger(target, "add", key, value);
+        } else if (hasChanged(value, oldValue)) {
+          trigger(target, "set", key, value, oldValue);
+        }
+        return this;
+      },
+      delete(key) {
+        const target = /* @__PURE__ */ toRaw(this);
+        const { has, get } = getProto(target);
+        let hadKey = has.call(target, key);
+        if (!hadKey) {
+          key = /* @__PURE__ */ toRaw(key);
+          hadKey = has.call(target, key);
+        } else if (true) {
+          checkIdentityKeys(target, has, key);
+        }
+        const oldValue = get ? get.call(target, key) : void 0;
+        const result = target.delete(key);
+        if (hadKey) {
+          trigger(target, "delete", key, void 0, oldValue);
+        }
+        return result;
+      },
+      clear() {
+        const target = /* @__PURE__ */ toRaw(this);
+        const hadItems = target.size !== 0;
+        const oldTarget = true ? isMap(target) ? new Map(target) : new Set(target) : void 0;
+        const result = target.clear();
+        if (hadItems) {
+          trigger(
+            target,
+            "clear",
+            void 0,
+            void 0,
+            oldTarget
+          );
+        }
+        return result;
+      }
+    }
+  );
+  const iteratorMethods = [
+    "keys",
+    "values",
+    "entries",
+    Symbol.iterator
+  ];
+  iteratorMethods.forEach((method) => {
+    instrumentations[method] = createIterableMethod(method, readonly2, shallow);
+  });
+  return instrumentations;
+}
+function createInstrumentationGetter(isReadonly2, shallow) {
+  const instrumentations = createInstrumentations(isReadonly2, shallow);
+  return (target, key, receiver) => {
+    if (key === "__v_isReactive") {
+      return !isReadonly2;
+    } else if (key === "__v_isReadonly") {
+      return isReadonly2;
+    } else if (key === "__v_raw") {
+      return target;
+    }
+    return Reflect.get(
+      hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+      key,
+      receiver
+    );
+  };
+}
+var mutableCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+};
+var readonlyCollectionHandlers = {
+  get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+};
+function checkIdentityKeys(target, has, key) {
+  const rawKey = /* @__PURE__ */ toRaw(key);
+  if (rawKey !== key && has.call(target, rawKey)) {
+    const type = toRawType(target);
+    warn(
+      `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
+    );
+  }
+}
+var reactiveMap = /* @__PURE__ */ new WeakMap();
+var shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+var readonlyMap = /* @__PURE__ */ new WeakMap();
+var shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+function targetTypeMap(rawType) {
+  switch (rawType) {
+    case "Object":
+    case "Array":
+      return 1;
+    case "Map":
+    case "Set":
+    case "WeakMap":
+    case "WeakSet":
+      return 2;
+    default:
+      return 0;
+  }
+}
+function getTargetType(value) {
+  return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
+}
+// @__NO_SIDE_EFFECTS__
+function reactive(target) {
+  if (/* @__PURE__ */ isReadonly(target)) {
+    return target;
+  }
+  return createReactiveObject(
+    target,
+    false,
+    mutableHandlers,
+    mutableCollectionHandlers,
+    reactiveMap
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function readonly(target) {
+  return createReactiveObject(
+    target,
+    true,
+    readonlyHandlers,
+    readonlyCollectionHandlers,
+    readonlyMap
+  );
+}
+function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+  if (!isObject(target)) {
+    if (true) {
+      warn(
+        `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
+          target
+        )}`
+      );
+    }
+    return target;
+  }
+  if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+    return target;
+  }
+  const targetType = getTargetType(target);
+  if (targetType === 0) {
+    return target;
+  }
+  const existingProxy = proxyMap.get(target);
+  if (existingProxy) {
+    return existingProxy;
+  }
+  const proxy = new Proxy(
+    target,
+    targetType === 2 ? collectionHandlers : baseHandlers
+  );
+  proxyMap.set(target, proxy);
+  return proxy;
+}
+// @__NO_SIDE_EFFECTS__
+function isReactive(value) {
+  if (/* @__PURE__ */ isReadonly(value)) {
+    return /* @__PURE__ */ isReactive(value["__v_raw"]);
+  }
+  return !!(value && value["__v_isReactive"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isReadonly(value) {
+  return !!(value && value["__v_isReadonly"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isShallow(value) {
+  return !!(value && value["__v_isShallow"]);
+}
+// @__NO_SIDE_EFFECTS__
+function isProxy(value) {
+  return value ? !!value["__v_raw"] : false;
+}
+// @__NO_SIDE_EFFECTS__
+function toRaw(observed) {
+  const raw = observed && observed["__v_raw"];
+  return raw ? /* @__PURE__ */ toRaw(raw) : observed;
+}
+var toReactive = (value) => isObject(value) ? /* @__PURE__ */ reactive(value) : value;
+var toReadonly = (value) => isObject(value) ? /* @__PURE__ */ readonly(value) : value;
+// @__NO_SIDE_EFFECTS__
+function isRef(r) {
+  return r ? r["__v_isRef"] === true : false;
+}
+// @__NO_SIDE_EFFECTS__
+function ref(value) {
+  return createRef(value, false);
+}
+// @__NO_SIDE_EFFECTS__
+function shallowRef(value) {
+  return createRef(value, true);
+}
+function createRef(rawValue, shallow) {
+  if (/* @__PURE__ */ isRef(rawValue)) {
+    return rawValue;
+  }
+  return new RefImpl(rawValue, shallow);
+}
+var RefImpl = class {
+  constructor(value, isShallow2) {
+    this.dep = new Dep();
+    this["__v_isRef"] = true;
+    this["__v_isShallow"] = false;
+    this._rawValue = isShallow2 ? value : /* @__PURE__ */ toRaw(value);
+    this._value = isShallow2 ? value : toReactive(value);
+    this["__v_isShallow"] = isShallow2;
+  }
+  get value() {
+    if (true) {
+      this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      });
+    } else {
+      this.dep.track();
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    const oldValue = this._rawValue;
+    const useDirectValue = this["__v_isShallow"] || /* @__PURE__ */ isShallow(newValue) || /* @__PURE__ */ isReadonly(newValue);
+    newValue = useDirectValue ? newValue : /* @__PURE__ */ toRaw(newValue);
+    if (hasChanged(newValue, oldValue)) {
+      this._rawValue = newValue;
+      this._value = useDirectValue ? newValue : toReactive(newValue);
+      if (true) {
+        this.dep.trigger({
+          target: this,
+          type: "set",
+          key: "value",
+          newValue,
+          oldValue
+        });
+      } else {
+        this.dep.trigger();
+      }
+    }
+  }
+};
+function triggerRef(ref2) {
+  if (ref2.dep) {
+    if (true) {
+      ref2.dep.trigger({
+        target: ref2,
+        type: "set",
+        key: "value",
+        newValue: ref2._value
+      });
+    } else {
+      ref2.dep.trigger();
+    }
+  }
+}
+var ComputedRefImpl = class {
+  constructor(fn, setter, isSSR) {
+    this.fn = fn;
+    this.setter = setter;
+    this._value = void 0;
+    this.dep = new Dep(this);
+    this.__v_isRef = true;
+    this.deps = void 0;
+    this.depsTail = void 0;
+    this.flags = 16;
+    this.globalVersion = globalVersion - 1;
+    this.next = void 0;
+    this.effect = this;
+    this["__v_isReadonly"] = !setter;
+    this.isSSR = isSSR;
+  }
+  /**
+   * @internal
+   */
+  notify() {
+    this.flags |= 16;
+    if (!(this.flags & 8) && // avoid infinite self recursion
+    activeSub !== this) {
+      batch(this, true);
+      return true;
+    } else if (true) ;
+  }
+  get value() {
+    const link = true ? this.dep.track({
+      target: this,
+      type: "get",
+      key: "value"
+    }) : this.dep.track();
+    refreshComputed(this);
+    if (link) {
+      link.version = this.dep.version;
+    }
+    return this._value;
+  }
+  set value(newValue) {
+    if (this.setter) {
+      this.setter(newValue);
+    } else if (true) {
+      warn("Write operation failed: computed value is readonly");
+    }
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+  let getter;
+  let setter;
+  if (isFunction(getterOrOptions)) {
+    getter = getterOrOptions;
+  } else {
+    getter = getterOrOptions.get;
+    setter = getterOrOptions.set;
+  }
+  const cRef = new ComputedRefImpl(getter, setter, isSSR);
+  if (debugOptions && !isSSR) {
+    cRef.onTrack = debugOptions.onTrack;
+    cRef.onTrigger = debugOptions.onTrigger;
+  }
+  return cRef;
+}
+var INITIAL_WATCHER_VALUE = {};
+var cleanupMap = /* @__PURE__ */ new WeakMap();
+var activeWatcher = void 0;
+function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+  if (owner) {
+    let cleanups = cleanupMap.get(owner);
+    if (!cleanups) cleanupMap.set(owner, cleanups = []);
+    cleanups.push(cleanupFn);
+  } else if (!failSilently) {
+    warn(
+      `onWatcherCleanup() was called when there was no active watcher to associate with.`
+    );
+  }
+}
+function watch(source, cb, options = EMPTY_OBJ) {
+  const { immediate, deep, once, scheduler, augmentJob, call } = options;
+  const warnInvalidSource = (s) => {
+    (options.onWarn || warn)(
+      `Invalid watch source: `,
+      s,
+      `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`
+    );
+  };
+  const reactiveGetter = (source2) => {
+    if (deep) return source2;
+    if (/* @__PURE__ */ isShallow(source2) || deep === false || deep === 0)
+      return traverse(source2, 1);
+    return traverse(source2);
+  };
+  let effect2;
+  let getter;
+  let cleanup;
+  let boundCleanup;
+  let forceTrigger = false;
+  let isMultiSource = false;
+  if (/* @__PURE__ */ isRef(source)) {
+    getter = () => source.value;
+    forceTrigger = /* @__PURE__ */ isShallow(source);
+  } else if (/* @__PURE__ */ isReactive(source)) {
+    getter = () => reactiveGetter(source);
+    forceTrigger = true;
+  } else if (isArray(source)) {
+    isMultiSource = true;
+    forceTrigger = source.some((s) => /* @__PURE__ */ isReactive(s) || /* @__PURE__ */ isShallow(s));
+    getter = () => source.map((s) => {
+      if (/* @__PURE__ */ isRef(s)) {
+        return s.value;
+      } else if (/* @__PURE__ */ isReactive(s)) {
+        return reactiveGetter(s);
+      } else if (isFunction(s)) {
+        return call ? call(s, 2) : s();
+      } else {
+        warnInvalidSource(s);
+      }
+    });
+  } else if (isFunction(source)) {
+    if (cb) {
+      getter = call ? () => call(source, 2) : source;
+    } else {
+      getter = () => {
+        if (cleanup) {
+          pauseTracking();
+          try {
+            cleanup();
+          } finally {
+            resetTracking();
+          }
+        }
+        const currentEffect = activeWatcher;
+        activeWatcher = effect2;
+        try {
+          return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+        } finally {
+          activeWatcher = currentEffect;
+        }
+      };
+    }
+  } else {
+    getter = NOOP;
+    warnInvalidSource(source);
+  }
+  if (cb && deep) {
+    const baseGetter = getter;
+    const depth = deep === true ? Infinity : deep;
+    getter = () => traverse(baseGetter(), depth);
+  }
+  const scope = getCurrentScope();
+  const watchHandle = () => {
+    effect2.stop();
+    if (scope && scope.active) {
+      remove(scope.effects, effect2);
+    }
+  };
+  if (once && cb) {
+    const _cb = cb;
+    cb = (...args) => {
+      _cb(...args);
+      watchHandle();
+    };
+  }
+  let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+  const job = (immediateFirstRun) => {
+    if (!(effect2.flags & 1) || !effect2.dirty && !immediateFirstRun) {
+      return;
+    }
+    if (cb) {
+      const newValue = effect2.run();
+      if (deep || forceTrigger || (isMultiSource ? newValue.some((v2, i) => hasChanged(v2, oldValue[i])) : hasChanged(newValue, oldValue))) {
+        if (cleanup) {
+          cleanup();
+        }
+        const currentWatcher = activeWatcher;
+        activeWatcher = effect2;
+        try {
+          const args = [
+            newValue,
+            // pass undefined as the old value when it's changed for the first time
+            oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+            boundCleanup
+          ];
+          oldValue = newValue;
+          call ? call(cb, 3, args) : (
+            // @ts-expect-error
+            cb(...args)
+          );
+        } finally {
+          activeWatcher = currentWatcher;
+        }
+      }
+    } else {
+      effect2.run();
+    }
+  };
+  if (augmentJob) {
+    augmentJob(job);
+  }
+  effect2 = new ReactiveEffect(getter);
+  effect2.scheduler = scheduler ? () => scheduler(job, false) : job;
+  boundCleanup = (fn) => onWatcherCleanup(fn, false, effect2);
+  cleanup = effect2.onStop = () => {
+    const cleanups = cleanupMap.get(effect2);
+    if (cleanups) {
+      if (call) {
+        call(cleanups, 4);
+      } else {
+        for (const cleanup2 of cleanups) cleanup2();
+      }
+      cleanupMap.delete(effect2);
+    }
+  };
+  if (true) {
+    effect2.onTrack = options.onTrack;
+    effect2.onTrigger = options.onTrigger;
+  }
+  if (cb) {
+    if (immediate) {
+      job(true);
+    } else {
+      oldValue = effect2.run();
+    }
+  } else if (scheduler) {
+    scheduler(job.bind(null, true), true);
+  } else {
+    effect2.run();
+  }
+  watchHandle.pause = effect2.pause.bind(effect2);
+  watchHandle.resume = effect2.resume.bind(effect2);
+  watchHandle.stop = watchHandle;
+  return watchHandle;
+}
+function traverse(value, depth = Infinity, seen) {
+  if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
+    return value;
+  }
+  seen = seen || /* @__PURE__ */ new Map();
+  if ((seen.get(value) || 0) >= depth) {
+    return value;
+  }
+  seen.set(value, depth);
+  depth--;
+  if (/* @__PURE__ */ isRef(value)) {
+    traverse(value.value, depth, seen);
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      traverse(value[i], depth, seen);
+    }
+  } else if (isSet(value) || isMap(value)) {
+    value.forEach((v2) => {
+      traverse(v2, depth, seen);
+    });
+  } else if (isPlainObject(value)) {
+    for (const key in value) {
+      traverse(value[key], depth, seen);
+    }
+    for (const key of Object.getOwnPropertySymbols(value)) {
+      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+        traverse(value[key], depth, seen);
+      }
+    }
+  }
+  return value;
+}
+
+// ../list/dist/index.js
+var import_just_debounce = __toESM(require_just_debounce(), 1);
+var import_fuzzysort = __toESM(require_fuzzysort(), 1);
+
+// inline-worker:__inline-worker
+init_live_reload();
+function inlineWorker(scriptText) {
+  let blob = new Blob([scriptText], { type: "text/javascript" });
+  let url = URL.createObjectURL(blob);
+  let worker = new Worker(url);
+  URL.revokeObjectURL(url);
+  return worker;
+}
+
+// ../list/dist/index.js
+var rr2 = Object.defineProperty;
+var yt = (e) => {
+  throw TypeError(e);
+};
+var ir = (e, t, n) => t in e ? rr2(e, t, { enumerable: true, configurable: true, writable: true, value: n }) : e[t] = n;
+var g = (e, t, n) => ir(e, typeof t != "symbol" ? t + "" : t, n);
+var or = (e, t, n) => t.has(e) || yt("Cannot " + n);
+var vt2 = (e, t, n) => t.has(e) ? yt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, n);
+var Q = (e, t, n) => (or(e, t, "access private method"), n);
+var _ = /* @__PURE__ */ new Map();
+var Et = (e, t) => {
+  let n = tr(t), i = [..._.values()].filter((o) => o !== e && o.instance && n.includes(o.instance));
+  if (!i.length) return;
+  let a = i.map((o) => {
+    let r = effect(() => {
+      if (!o.items.value.length) return;
+      let s = o.items.value.map((l) => (l.currentIndex = void 0, e.createItem(l.element)));
+      o.renderedItems.clear(), o.items.value = [], e.items.value = [...e.items.value, ...s];
+    });
+    return () => r.effect.stop();
+  });
+  return () => {
+    a.forEach((o) => o());
+  };
+};
+var K2 = "ad-list";
+var Se = { cache: { type: "boolean", default: true }, showquery: { type: "boolean", default: false }, highlight: { type: "boolean", default: false }, itemsperpage: { type: "number", default: 0 }, load: { type: "string", default: "" }, combine: { type: "string", default: "" }, filteringclass: { type: "string", default: "is-list-filtering" }, sortingclass: { type: "string", default: "is-list-sorting" }, loadingclass: { type: "string", default: "is-list-loading" }, resetix: { type: "boolean", default: false }, threshold: { type: "number", default: -20 }, loadcount: { type: "string", default: "" }, pagesiblings: { type: "string", default: "1" }, pageboundary: { type: "string", default: "1" }, a11y: { type: "boolean", default: true } };
+var We = ["wrapper", "list", "item", "item-link", "clear", "pagination-wrapper", "pagination-next", "pagination-previous", "page-count", "empty", "sort-trigger", "dropdown-label", "loader", "items-count", "visible-count", "visible-count-from", "visible-count-to", "results-count", "facet-count", "page-button", "page-dots", "filters", "initial", "tag", "tag-field", "tag-value", "tag-operator", "tag-operator-equal", "tag-operator-not-equal", "tag-operator-contain", "tag-operator-not-contain", "tag-operator-start", "tag-operator-not-start", "tag-operator-end", "tag-operator-not-end", "tag-operator-greater", "tag-operator-greater-equal", "tag-operator-less", "tag-operator-less-equal", "tag-operator-empty", "tag-operator-not-empty", "tag-remove", "tag-group", "tag-group-remove", "condition-group", "condition-group-match", "condition-groups-match", "condition-group-add", "condition-groups-add", "condition-group-remove", "condition", "condition-match", "condition-field", "condition-operator", "condition-value", "condition-add", "condition-remove", "slider", "tabs", "tab-link", "select", "select-value", "nest-target", "nest-slugs", "scroll-anchor", "scroll-anchor-filter", "scroll-anchor-sort", "scroll-anchor-pagination", "previous-item", "next-item", "previous-empty", "next-empty"];
+var w = "text";
+var H = "number";
+var N = "date";
+var be2 = "select-one";
+var Te = "select-multiple";
+var Ne = "contain";
+var Be = "not-contain";
+var $e = "start";
+var Ke = "not-start";
+var Ue = "end";
+var qe = "not-end";
+var Z = "equal";
+var J = "not-equal";
+var de = "greater";
+var me = "greater-equal";
+var fe = "less";
+var he = "less-equal";
+var ee = "empty";
+var te = "not-empty";
+var D = { field: { key: "field" }, fieldmatch: { key: "fieldmatch", values: ["and", "or"], defaultValue: "or" }, filtermatch: { key: "filtermatch", values: ["and", "or"], defaultValue: "or" }, conditionsmatch: { key: "conditionsmatch", values: ["and", "or"], defaultValue: "and" }, groupsmatch: { key: "groupsmatch", values: ["and", "or"], defaultValue: "and" }, fieldtype: { key: "fieldtype", values: ["number", "date"] }, reverse: { key: "reverse", values: ["true"] }, debounce: { key: "debounce", isNumeric: true }, ascclass: { key: "ascclass", defaultValue: "is-list-asc" }, descclass: { key: "descclass", defaultValue: "is-list-desc" }, activeclass: { key: "activeclass", defaultValue: "is-list-active" }, dynamicdisabledclass: { key: "dynamicdisabledclass", defaultValue: "is-list-dynamic-disabled" }, load: { key: "load", values: ["more", "infinite", "pagination", "all"] }, loadcount: { key: "loadcount", values: ["all"] }, threshold: { key: "threshold", defaultValue: "-20", isNumeric: true }, pagesiblings: { key: "pagesiblings", defaultValue: "1" }, pageboundary: { key: "pageboundary", defaultValue: "1" }, paginationdisabledclass: { key: "paginationdisabledclass", defaultValue: "is-list-pagination-disabled" }, easing: { key: "easing" }, duration: { key: "duration", defaultValue: "1000", isNumeric: true }, showquery: { key: "showquery", values: ["true"] }, highlight: { key: "highlight", values: ["true"] }, highlightclass: { key: "highlightclass", defaultValue: "is-list-highlight" }, emptyfacet: { key: "emptyfacet", values: ["hide", "add-class"] }, emptyfacetclass: { key: "emptyfacetclass", defaultValue: "is-list-emptyfacet" }, operator: { key: "operator", values: [Z, J, Ne, Be, $e, Ke, Ue, qe, me, de, he, fe, ee, te] }, fuzzy: { key: "fuzzy", isNumeric: true }, filteron: { key: "filteron", values: ["input", "change", "submit"], defaultValue: "input" }, allowsubmit: { key: "allowsubmit", values: ["true"] }, value: { key: "value" }, split: { key: "split" }, combine: { key: "combine" }, nest: { key: "nest" }, cache: { key: "cache", values: ["true"], defaultValue: "true" }, tagfield: { key: "tagfield" }, tagvalues: { key: "tagvalues", values: ["combined", "separate"], defaultValue: "combined" }, showtag: { key: "showtag", values: ["false"] }, formatdisplay: { key: "formatdisplay", values: ["true"] }, position: { key: "position", isNumeric: true, defaultValue: "1" }, repeat: { key: "repeat", isNumeric: true }, interactive: { key: "interactive", values: ["true"] }, itemsperpage: { key: "itemsperpage", isNumeric: true }, filteringclass: { key: "filteringclass", defaultValue: "is-list-filtering" }, loadingclass: { key: "loadingclass", defaultValue: "is-list-loading" }, sortingclass: { key: "sortingclass", defaultValue: "is-list-sorting" }, startingclass: { key: "startingclass", defaultValue: "is-list-starting" }, stagger: { key: "stagger", isNumeric: true }, resetix: { key: "resetix", values: ["true"] }, facetcount: { key: "facetcount" }, disabled: { key: "disabled", values: ["true"] }, a11y: { key: "a11y", values: ["false"] } };
+var bt = { main: 0, medium: 1, small: 2, tiny: 3 };
+var Ge = { text: { single: { [Ne]: [w], [Be]: [w], [$e]: [w], [Ke]: [w], [Ue]: [w], [qe]: [w], [Z]: [Te, be2, w], [J]: [Te, be2, w], [ee]: [], [te]: [] }, multiple: { [Ne]: [w], [Be]: [w], [$e]: [w], [Ke]: [w], [Ue]: [w], [qe]: [w], [Z]: [Te, be2, w], [J]: [Te, be2, w], [ee]: [], [te]: [] } }, number: { single: { [Z]: [H, w], [J]: [H, w], [fe]: [H, w], [he]: [H, w], [de]: [H, w], [me]: [H, w], [ee]: [], [te]: [] }, multiple: { [Z]: [H, w], [J]: [H, w], [fe]: [H, w], [he]: [H, w], [de]: [H, w], [me]: [H, w], [ee]: [], [te]: [] } }, date: { single: { [Z]: [N, w], [J]: [N, w], [fe]: [N, w], [he]: [N, w], [de]: [N, w], [me]: [N, w], [ee]: [], [te]: [] }, multiple: { [Z]: [N, w], [J]: [N, w], [fe]: [N, w], [he]: [N, w], [de]: [N, w], [me]: [N, w], [ee]: [], [te]: [] } } };
+var Le = "--ad-list-renderindex";
+window.CSS?.registerProperty?.({ name: Le, syntax: "<number>", inherits: false, initialValue: "0" });
+var { getElementSelector: I, queryElement: v, queryAllElements: R, getSettingSelector: B, getSettingAttributeName: ur, getClosestElement: zo2, getAttribute: y, hasAttributeValue: G, getInstance: j2, getInstanceSelector: Yo2, getPresenceSelector: Xo } = Jo(K2, We, D);
+var ne = ur("value");
+var we = (e) => {
+  let t = y(e, "split");
+  return t === "true" ? " " : t;
+};
+var cr = { wrapper: `.${Yt.wrapper}`, list: `.${Yt.list}`, item: `.${Yt.item}`, "pagination-wrapper": `.${Yt.paginationWrapper}`, "pagination-next": `.${Yt.paginationNext}`, "pagination-previous": `.${Yt.paginationPrevious}`, "page-count": `.${Yt.pageCount}`, empty: `.${Yt.emptyState}` };
+var P = (e, t) => `:is(${cr[e]}, ${I(e, t)})`;
+function F2(e, t) {
+  let n = e.closest(P("wrapper"));
+  if (!n) return null;
+  let i = n.querySelector(P("list"));
+  return t === "wrapper" ? n : t === "list" ? i : t === "item" ? [...i?.querySelectorAll(`:scope > ${P(t)}`) || []] : t === "page-count" ? n.querySelector(P(t)) : t === "empty" ? n.querySelector(`:scope > ${P(t)}`) : n.querySelector(P(t));
+}
+var re = (e = document) => [...e.querySelectorAll(P("wrapper"))];
+var je = (e) => {
+  let { href: t } = e, { searchParams: n } = new URL(t);
+  return [...n.entries()];
+};
+var ge = class {
+  constructor(t, n, i) {
+    this.element = t;
+    this.list = n;
+    this.currentIndex = i;
+    g(this, "id", crypto.randomUUID());
+    g(this, "href");
+    g(this, "url");
+    g(this, "startingClass");
+    g(this, "highlightClass");
+    g(this, "stagger");
+    g(this, "fields", {});
+    g(this, "fieldElements", {});
+    g(this, "nesting");
+    let a = v("item-link", { scope: t });
+    if (sn(a) || (a = t.querySelector("a")), this.href = a?.href, this.highlightClass = y(t, "highlightclass"), this.startingClass = y(t, "startingclass"), this.stagger = y(t, "stagger"), this.href) try {
+      this.url = new URL(this.href, window.location.origin);
+    } catch {
+    }
+    this.collectFields();
+  }
+  collectFields() {
+    var i, a, o;
+    this.fields = {}, this.fieldElements = {};
+    let t = B("field"), n = [...this.element.querySelectorAll(t)];
+    for (let r of n) {
+      let s = y(r, "field")?.trim();
+      if (!s) continue;
+      let l = r.textContent;
+      if (!l) continue;
+      let u = y(r, "fieldtype", { filterInvalid: true }) || "text", d = u === "number" ? qo(l) : u === "date" ? Sn(l) : l.trim();
+      if (d === void 0) continue;
+      (i = this.fieldElements)[s] || (i[s] = []), this.fieldElements[s].push({ value: d, element: r, originalHTML: r.innerHTML });
+      let p = P("list"), c = r.closest(p);
+      if (this.list.listElement && c && c !== this.list.listElement) {
+        (a = this.fields)[s] || (a[s] = { type: u, rawValue: [], value: [] });
+        let f = this.fields[s];
+        if (f.type !== u || !Array.isArray(f.value) || !Array.isArray(f.rawValue) || f.value.some((L) => L === d) || f.rawValue.some((L) => L === l)) continue;
+        f.value.push(d), f.rawValue.push(l);
+      } else (o = this.fields)[s] || (o[s] = { fieldKey: s, type: u, rawValue: l, value: d });
+    }
+  }
+  highlight(t) {
+    if (this.list.highlight) for (let n in this.fields) {
+      let i = this.fieldElements[n];
+      if (!i) continue;
+      let a = t[n];
+      if (!a) {
+        for (let { element: o, originalHTML: r } of i) o.innerHTML = r;
+        continue;
+      }
+      for (let { value: o, element: r, originalHTML: s } of i) {
+        r.innerHTML = s;
+        let l = a.find(({ fieldValue: p }) => p === o);
+        if (!l) continue;
+        let u = new RegExp(l.filterValue, "gi"), d = (p) => {
+          for (let c of Array.from(p.childNodes)) {
+            if (c.nodeType === Node.ELEMENT_NODE) {
+              d(c);
+              continue;
+            }
+            if (c.nodeType !== Node.TEXT_NODE) continue;
+            let m = c.textContent || "";
+            if (!u.test(m)) continue;
+            let f = document.createElement("template");
+            f.innerHTML = m.replace(u, `<span class="${this.highlightClass}">$&</span>`), c.replaceWith(f.content);
+          }
+        };
+        d(r);
+      }
+    }
+  }
+};
+var O;
+var Lt;
+var wt;
+var Ct;
+var xt;
+var Ye;
+var le = class {
+  constructor(t, n, i = true, a = {}) {
+    this.wrapperElement = t;
+    this.pageIndex = n;
+    this.options = a;
+    vt2(this, O);
+    g(this, "items", shallowRef([]));
+    g(this, "hooks", { start: { index: 0, callbacks: [], result: shallowRef([]) }, filter: { index: 1, previous: "start", callbacks: [], result: shallowRef([]) }, sort: { index: 2, previous: "filter", callbacks: [], result: shallowRef([]) }, static: { index: 3, previous: "sort", callbacks: [], result: shallowRef([]) }, pagination: { index: 4, previous: "static", callbacks: [], result: shallowRef([]) }, beforeRender: { index: 5, previous: "pagination", callbacks: [], result: shallowRef([]) }, render: { index: 6, previous: "beforeRender", callbacks: [], result: shallowRef([]) }, afterRender: { index: 7, previous: "render", callbacks: [], result: shallowRef([]) } });
+    g(this, "currentHook");
+    g(this, "triggeredHook");
+    g(this, "queuedHook");
+    g(this, "renderedItems", /* @__PURE__ */ new Set());
+    g(this, "instance");
+    g(this, "listElement");
+    g(this, "paginationWrapperElement");
+    g(this, "paginationCountElement");
+    g(this, "allPaginationPreviousElements", shallowRef(/* @__PURE__ */ new Set()));
+    g(this, "paginationPreviousCMSElement", computed(() => [...this.allPaginationPreviousElements.value].filter(sn).find((t2) => t2.classList.contains(Yt.paginationPrevious))));
+    g(this, "allPaginationNextElements", shallowRef(/* @__PURE__ */ new Set()));
+    g(this, "paginationNextCMSElement", computed(() => [...this.allPaginationNextElements.value].filter(sn).find((t2) => t2.classList.contains(Yt.paginationNext))));
+    g(this, "emptyElement", ref());
+    g(this, "initialElement");
+    g(this, "loaderElement");
+    g(this, "itemsCountElement");
+    g(this, "resultsCountElement");
+    g(this, "visibleCountElement");
+    g(this, "visibleCountFromElement");
+    g(this, "visibleCountToElement");
+    g(this, "scrollAnchorElement");
+    g(this, "scrollAnchorFilterElement");
+    g(this, "scrollAnchorSortElement");
+    g(this, "scrollAnchorPaginationElement");
+    g(this, "initialItemsPerPage");
+    g(this, "customItemsPerPage");
+    g(this, "itemsPerPage");
+    g(this, "totalPages", computed(() => Math.ceil(this.hooks.static.result.value.length / this.itemsPerPage.value)));
+    g(this, "currentPage", ref(1));
+    g(this, "filters", ref({ groups: [] }));
+    g(this, "allFieldsData", computed(() => this.items.value.reduce((t2, n2) => {
+      for (let [i2, a2] of Object.entries(n2.fields)) {
+        t2[i2] || (t2[i2] = { type: a2.type, valueType: Array.isArray(a2.value) ? "multiple" : "single", rawValues: /* @__PURE__ */ new Set() });
+        let o2 = Array.isArray(a2.rawValue) ? a2.rawValue : [a2.rawValue];
+        for (let r2 of o2) t2[i2].rawValues.add(r2);
+      }
+      return t2;
+    }, {})));
+    g(this, "sorting", ref({}));
+    g(this, "loading", ref(false));
+    g(this, "hasInteracted", computed(() => this.sorting.value.interacted || this.filters.value.groups.some((t2) => t2.conditions.some((n2) => n2.interacted))));
+    g(this, "hasFilters", computed(() => this.filters.value.groups.some((t2) => t2.conditions.some((n2) => !!n2.value?.length))));
+    g(this, "showQuery");
+    g(this, "highlight");
+    g(this, "cache");
+    g(this, "webflowModules", /* @__PURE__ */ new Set());
+    g(this, "paginationSearchParam");
+    g(this, "searchParamsPrefix");
+    g(this, "loadingSearchParamsData");
+    g(this, "loadingPaginationElements");
+    g(this, "loadingPaginatedItems");
+    g(this, "readingFilters");
+    g(this, "settingFilters");
+    g(this, "destroy", () => {
+    });
+    g(this, "watch", watch);
+    g(this, "effect", effect);
+    g(this, "createItem", (t2) => new ge(t2, this));
+    let o = F2(t, "list");
+    this.listElement = o;
+    let r = j2(o || t);
+    this.instance = r, this.paginationWrapperElement = F2(t, "pagination-wrapper"), this.paginationCountElement = F2(t, "page-count"), this.emptyElement.value = F2(t, "empty") || v("empty", { instance: r }), this.initialElement = v("initial", { instance: r }), this.loaderElement = v("loader", { instance: r }), this.itemsCountElement = v("items-count", { instance: r }), this.visibleCountElement = v("visible-count", { instance: r }), this.visibleCountFromElement = v("visible-count-from", { instance: r }), this.visibleCountToElement = v("visible-count-to", { instance: r }), this.resultsCountElement = v("results-count", { instance: r }), this.scrollAnchorElement = v("scroll-anchor", { instance: r }), this.scrollAnchorFilterElement = v("scroll-anchor-filter", { instance: r }), this.scrollAnchorSortElement = v("scroll-anchor-sort", { instance: r }), this.scrollAnchorPaginationElement = v("scroll-anchor-pagination", { instance: r }), this.cache = a.cache ?? true, this.showQuery = a.showquery ?? false, this.highlight = a.highlight ?? false;
+    let s = F2(t, "pagination-next");
+    s && this.allPaginationNextElements.value.add(s), R("pagination-next", { instance: r }).forEach((c) => this.allPaginationNextElements.value.add(c));
+    let l = F2(t, "pagination-previous");
+    l && this.allPaginationPreviousElements.value.add(l), R("pagination-previous", { instance: r }).forEach((c) => this.allPaginationPreviousElements.value.add(c));
+    let u = F2(t, "item");
+    if (this.customItemsPerPage = a.itemsperpage || 0, this.initialItemsPerPage = this.customItemsPerPage || u.length, this.itemsPerPage = ref(this.initialItemsPerPage), o) {
+      let c = u.map((m, f) => new ge(m, this, f));
+      this.items.value = c, this.renderedItems = new Set(c);
+    }
+    if (!i) return;
+    this.loadingSearchParamsData = Q(this, O, Ct).call(this).then((c) => {
+      this.searchParamsPrefix = c?.split("_")[0];
+    }), this.loadingPaginationElements = Q(this, O, xt).call(this);
+    let d = Q(this, O, wt).call(this), p = Q(this, O, Lt).call(this);
+    this.destroy = () => {
+      p(), d(), _.delete(this.wrapperElement);
+    };
+  }
+  addHook(t, n) {
+    let i = this.hooks[t];
+    return i.callbacks.push(n), () => {
+      i.callbacks = i.callbacks.filter((a) => a !== n);
+    };
+  }
+  triggerHook(t, { scrollToAnchor: n, resetCurrentPage: i } = {}) {
+    if (this.currentHook) {
+      let a = this.hooks[t].index;
+      if (this.hooks[this.currentHook].index >= a) if (this.queuedHook) {
+        let r = this.hooks[this.queuedHook].index;
+        this.queuedHook = a < r ? t : this.queuedHook;
+      } else this.queuedHook = t;
+      return;
+    }
+    return this.triggeredHook = t, this.currentHook = t, n && this.scrollToAnchor(t), i && (this.currentPage.value = 1), Q(this, O, Ye).call(this, t);
+  }
+  scrollToAnchor(t) {
+    let { scrollAnchorFilterElement: n, scrollAnchorSortElement: i, scrollAnchorPaginationElement: a, scrollAnchorElement: o } = this, r = (t === "filter" ? n : t === "sort" ? i : t === "pagination" ? a : o) || o;
+    r && r.scrollIntoView({ behavior: "smooth" });
+  }
+  async getSearchParam(t, n = true) {
+    await this.loadingSearchParamsData;
+    let { searchParams: i } = new URL(location.href);
+    if (!n) return i.get(t);
+    let a = [this.instance, this.searchParamsPrefix, this.pageIndex.toString()];
+    for (let o of a) {
+      if (!o) continue;
+      let r = `${o}_${t}`, s = i.get(r);
+      if (s) return s;
+    }
+    return null;
+  }
+  async getAllSearchParams(t = true) {
+    await this.loadingSearchParamsData;
+    let { searchParams: n } = new URL(location.href);
+    if (!t) return [...n.entries()];
+    let i = /* @__PURE__ */ new Map(), a = [this.instance, this.searchParamsPrefix, this.pageIndex.toString()];
+    for (let [o, r] of n) for (let s of a) {
+      if (!s || !o.startsWith(`${s}_`)) continue;
+      let l = o.replace(`${s}_`, "");
+      i.set(l, r);
+      break;
+    }
+    return [...i.entries()];
+  }
+  async setSearchParam(t, n, { usePrefix: i = true, useSearchParamsPrefix: a = false } = {}) {
+    await this.loadingSearchParamsData;
+    let o = new URL(location.href), r = t;
+    a ? r = `${this.searchParamsPrefix}_${t}` : i && (r = `${this.instance || this.searchParamsPrefix || this.pageIndex.toString()}_${t}`), n ? o.searchParams.set(r, n) : o.searchParams.delete(r), history.replaceState({}, "", o.toString());
+  }
+  get listOrWrapper() {
+    return this.listElement || this.wrapperElement;
+  }
+};
+O = /* @__PURE__ */ new WeakSet(), Lt = function() {
+  let t = [];
+  this.addHook("render", async (i) => {
+    let a = 0, o = Promise.all(i.map((r, s) => {
+      let l = i[s - 1], u = async () => {
+        r.element.style.setProperty(Le, `${a}`), r.element.classList.add(r.startingClass), r.stagger && (r.element.style.transitionDelay = `${a * r.stagger}ms`), l ? l.element.after(r.element) : this.listElement?.prepend(r.element), r.currentIndex = s, a += 1, await new Promise(requestAnimationFrame), r.element.classList.remove(r.startingClass);
+        let d = r.element.getAnimations({ subtree: true });
+        try {
+          await Promise.all(d.map((p) => p.finished));
+        } catch {
+        }
+        r.element.style.removeProperty(Le), r.stagger && (r.element.style.transitionDelay = "");
+      };
+      if (ie(r.currentIndex)) {
+        if (this.renderedItems.delete(r), r.currentIndex !== s) return u();
+      } else return u();
+    }));
+    return this.renderedItems.forEach((r) => {
+      r.element.remove(), r.currentIndex = void 0;
+    }), this.renderedItems = new Set(i), await o, i;
+  }), this.addHook("afterRender", async () => {
+    Mo([...this.webflowModules]);
+  });
+  let n = (i) => {
+    let { previous: a } = this.hooks[i];
+    if (!a) {
+      let r = watch(this.items, () => this.triggerHook(i), { immediate: true });
+      t.push(r);
+      return;
+    }
+    let o = watch(this.hooks[a].result, async () => {
+      if (await Q(this, O, Ye).call(this, i), i === "afterRender" && (this.currentHook = void 0, this.triggeredHook = void 0, this.queuedHook)) {
+        let { queuedHook: r } = this;
+        this.queuedHook = void 0, this.triggerHook(r);
+      }
+    });
+    t.push(o), n(a);
+  };
+  return n("afterRender"), () => {
+    t.forEach((i) => i()), t.length = 0;
+  };
+}, wt = function() {
+  let t = effect(() => {
+    this.itemsCountElement && (this.itemsCountElement.textContent = `${this.items.value.length}`);
+  }), n = effect(() => {
+    if (!this.initialElement) return;
+    let o = !this.hasInteracted.value || !this.hasFilters.value;
+    this.wrapperElement.style.display = o ? "none" : "", this.initialElement.style.display = o ? "" : "none";
+  }), i = effect(() => {
+    this.loaderElement && (this.loaderElement.style.display = this.loading.value ? "" : "none");
+  }), a = watch([this.hooks.render.result, this.emptyElement], ([o, r]) => {
+    let s = o.length > 0;
+    this.listElement && (this.listElement.style.display = s ? "" : "none"), r && (r.style.display = s ? "none" : "");
+  });
+  return () => {
+    t.effect.stop(), n.effect.stop(), i.effect.stop(), a();
+  };
+}, Ct = async function() {
+  let t = this.paginationNextCMSElement.value || this.paginationPreviousCMSElement.value;
+  if (!t) return;
+  let n = je(t);
+  if (!n.length) return;
+  let i, a;
+  if (n.length === 1) {
+    let [s] = n;
+    if (!s) return;
+    [i, a] = s;
+  } else {
+    let { origin: s, pathname: l } = location, u = await Po(s + l);
+    if (!u) return;
+    let p = u.querySelectorAll(P("wrapper"))[this.pageIndex];
+    if (!p) return;
+    let c = F2(p, "pagination-next");
+    if (!c) return;
+    let [m] = je(c) || [];
+    if (!m) return;
+    [i] = m, [, a] = n.find(([f]) => f === i) || [];
+  }
+  if (!i || !a) return;
+  let o = parseInt(a), r = this.paginationNextCMSElement.value ? o - 1 : o + 1;
+  return this.paginationSearchParam = i, this.currentPage.value = r, i;
+}, xt = async function() {
+  await this.loadingSearchParamsData;
+  let { origin: t, pathname: n } = window.location, { wrapperElement: i, listElement: a, paginationWrapperElement: o, paginationNextCMSElement: r, paginationPreviousCMSElement: s, emptyElement: l, currentPage: u, paginationSearchParam: d, pageIndex: p } = this;
+  await Promise.all([(async () => {
+    if (r.value) return;
+    let c = u.value;
+    if (!c || c === 1 || !d) return;
+    let m = await Po(`${t}${n}?${d}=${c - 1}`);
+    if (!m) return;
+    let L = re(m)[p];
+    if (!L) return;
+    let h = F2(L, "pagination-next");
+    if (!h) return;
+    let E = s.value?.parentElement || o;
+    E && (h.style.display = "none", E.append(h), this.allPaginationNextElements.value.add(h));
+  })(), (async () => {
+    if (s.value && l.value || !d) return;
+    let c = await Po(`${t}${n}?${d}=9999`);
+    if (!c) return;
+    let f = re(c)[p];
+    if (!f) return;
+    let L = F2(f, "pagination-previous"), h = F2(f, "empty");
+    if (L && !s.value) {
+      let E = r.value?.parentElement || o;
+      if (!E) return;
+      L.style.display = "none", E.prepend(L), this.allPaginationPreviousElements.value.add(L);
+    }
+    h && !l.value && (h.style.display = "none", i.insertBefore(h, a?.nextSibling || null), l.value = h);
+  })()]);
+}, Ye = async function(t) {
+  this.currentHook = t;
+  let n = this.hooks[t], { previous: i } = n, o = (i ? this.hooks[i].result : void 0)?.value || this.items.value;
+  for (let r of n.callbacks) o = await r(o) || o;
+  n.result.value = [...o];
+};
+var It = (e) => {
+  let t = effect(() => {
+    let n = e.hooks.filter.result.value;
+    e.resultsCountElement && (e.resultsCountElement.textContent = `${n.length}`);
+  });
+  return () => t.effect.stop();
+};
+var Me = (e) => {
+  let t = G(e, "allowsubmit", "true"), n = kn(e, "submit", (a) => {
+    if (t) return;
+    a.preventDefault(), a.stopPropagation();
+    let { activeElement: o } = document, r = matchMedia("(pointer: coarse)").matches, s = /Mobi|Android|iPhone|iPad/i.test(navigator.userAgent);
+    (r || s) && q(o) && o.blur();
+  }), i = kn(e, "change", (a) => {
+    let { target: o } = a;
+    on(o) && br(o);
+  });
+  return () => {
+    n(), i();
+  };
+};
+var br = (e) => {
+  let t = y(e, "activeclass");
+  switch (e.type) {
+    case "checkbox": {
+      let { checked: n } = e;
+      Yo(e).classList.toggle(t, n);
+      break;
+    }
+    case "radio": {
+      let n = gt(e);
+      for (let i of n) Yo(i).classList.toggle(t, i.checked);
+      break;
+    }
+    default:
+      e.classList.toggle(t, !!e.value);
+  }
+};
+var Xe = (e, t, n) => {
+  if (t === "date" || t === "time" || t === "datetime-local" || t === "month" || t === "week") {
+    let i = Sn(e);
+    return i === void 0 || isNaN(i.getTime()) ? null : i;
+  }
+  if (t === "number" || t === "range") {
+    let i = qo(e);
+    return i === void 0 || isNaN(i) ? null : i;
+  }
+  return e;
+};
+var Ae = (e, t) => e.split(t).map((n) => n.trim()).filter(Boolean);
+var wr = /\[field=(?:"([^"]*)"|([^\]]+))\]/;
+var Cr = new RegExp(`^(${D.operator.values.join("|")})`);
+var kt = D.fieldmatch.values.join("|");
+var xr = new RegExp(`\\[fieldmatch=(${kt}|"(${kt})")\\]`);
+var ie2 = (e) => e.value === "or" ? "or" : "and";
+var Ie = (e) => {
+  let t, n, i, a = e.match(Cr);
+  a && (t = a[1]);
+  let o = e.match(wr);
+  o && (n = o[1] || o[2]);
+  let r = e.match(xr);
+  return r && (i = r[2] || r[1]), { op: t, fieldKey: n, fieldMatch: i };
+};
+var Ft2 = (e, t, n) => {
+  let i = kn(t, "change", () => {
+    let r = ue(e, n);
+    if (!r) return;
+    let s = ie2(t);
+    r.conditionsMatch = s;
+  }), a = y(t, "dynamicdisabledclass"), o = effect(() => {
+    let r = n.conditions.value.length <= 1;
+    t.setAttribute("aria-disabled", r ? "true" : "false"), t.classList.toggle(a, r);
+  });
+  return () => {
+    i(), o.effect.stop();
+  };
+};
+var Rt = (e, t, n, i) => kn(t, "click", () => {
+  let o = F(n), r = Je(e, o, i);
+  if (!r) return;
+  let s = i.conditions.value, l = s[s.length - 2];
+  l ? l.element.after(r.element) : i.element.append(r.element);
+});
+var kr = (e, t, n) => {
+  let i = kn(e, "click", () => {
+    n.conditions.value.length <= 1 || t.cleanup();
+  }), a = y(e, "dynamicdisabledclass"), o = effect(() => {
+    let r = n.conditions.value.length <= 1;
+    e.setAttribute("aria-disabled", r ? "true" : "false"), e.classList.toggle(a, r);
+  });
+  return () => {
+    i(), o.effect.stop();
+  };
+};
+var Pr = (e, t, n) => {
+  let i = kn(t, "change", () => {
+    let o = q2(e, n);
+    o && (o.fieldKey = t.value);
+  }), a = effect(() => {
+    let o = false;
+    for (let r of t.options) {
+      let s = !!e.allFieldsData.value[r.value];
+      r.style.display = s ? "" : "none", r.disabled = !s, !s && r.selected && (r.selected = false, o = true);
+    }
+    o && A(t, ["input", "change"]);
+  });
+  return () => {
+    i(), a.effect.stop();
+  };
+};
+var Fr = (e, t, n) => {
+  let i = kn(t, "change", () => {
+    let r = q2(e, n);
+    if (!r) return;
+    let { op: s, fieldMatch: l = D.fieldmatch.defaultValue } = Ie(t.value);
+    Object.assign(r, { op: s, fieldMatch: l });
+  }), a = ([r, s]) => {
+    let l = r ? s[r] : void 0, u = Object.keys(s), d = false, { optionsData: p, optionsDataByOp: c, optionsToHide: m, optionsToDisplay: f } = [...t.options].reduce((h, E) => {
+      let S = () => (h.optionsToHide.push(E), h);
+      if (!E.value || !l) return S();
+      let C = Ie(E.value);
+      if (!C.op) return S();
+      let b = !C.fieldKey;
+      if (C.fieldKey && (b = (C.fieldKey === "*" ? u : tr(C.fieldKey)).some((x) => x === r)), !b || !!!Ge[l.type]?.[l.valueType]?.[C.op]) return S();
+      let T = { option: E, ...C };
+      return h.optionsData.push(T), h.optionsDataByOp.set(C.op, [...h.optionsDataByOp.get(C.op) || [], T]), h;
+    }, { optionsData: [], optionsDataByOp: /* @__PURE__ */ new Map(), optionsToHide: [], optionsToDisplay: [] }), L = l?.valueType === "multiple";
+    for (let { op: h, option: E, fieldMatch: S = D.fieldmatch.defaultValue } of p) {
+      let C = c.get(h) || [], b;
+      L ? b = C.find((T) => T.fieldMatch === S) || C.find((T) => T.fieldMatch) || C.find((T) => !T.fieldMatch) : b = C.find((T) => !T.fieldMatch), b?.option !== E ? m.push(E) : f.push(E);
+    }
+    for (let h of f) h.style.display = "", h.disabled = false;
+    for (let h of m) h.style.display = "none", h.disabled = true, h.selected && (h.selected = false, d = true);
+    d && A(t, ["input", "change"]);
+  }, o = watch([() => q2(e, n)?.fieldKey, e.allFieldsData], (0, import_just_debounce.default)(a, 0), { immediate: true });
+  return () => {
+    i(), o();
+  };
+};
+var Rr = (e, t, n, i) => {
+  let a = new Comment();
+  t.after(a);
+  let { instance: o } = e, r = I("condition", { instance: o }), s = I("condition-value", { instance: o }), l = `:is(${s}):not(:is(${r}) :is(${s}))`, u = R("condition-value", { scope: n }), d = document.querySelectorAll(l), p = /* @__PURE__ */ new Map();
+  for (let b of u) {
+    if (!on(b)) continue;
+    let M = b.type;
+    p.has(M) || p.set(M, b);
+  }
+  for (let b of d) {
+    if (!on(b)) continue;
+    let M = b.type;
+    if (p.has(M)) continue;
+    let T = F(b);
+    p.set(M, T);
+  }
+  let c, m = () => {
+    if (e.settingFilters || !c) return;
+    let b = q2(e, i);
+    if (!b) return;
+    e.readingFilters = true;
+    let M = p.get(c), T = y(M, "fuzzy"), A2 = we(M), x = Dt2(M);
+    Qt(x) && A2 && (x = Ae(x, A2)), Object.assign(b, { value: x, fuzzyThreshold: T, type: c }), e.readingFilters = false;
+  }, f = [...p].map(([, b]) => {
+    let M = y(b, "filteron", { filterInvalid: true }), T = y(b, "debounce"), A2 = M === "submit" ? b.form : b, x = T ? (0, import_just_debounce.default)(m, T) : m;
+    return kn(A2, M, x);
+  }), L = ([b, M, T]) => {
+    let A2 = b ? T[b] : void 0, x = [];
+    A2 && M && (x = Ge[A2.type]?.[A2.valueType]?.[M] || []);
+    let $ = c;
+    c = x.find((k) => p.has(k));
+    for (let [k, V] of p) k === c ? a.after(V) : V.remove();
+    if (c && $ !== c) {
+      let k = p.get(c);
+      j(k) ? k.selectedIndex = 0 : k.value = "", A(k, ["input", "change"]);
+    }
+  }, h = ([b, M]) => {
+    let T = [...p.values()].filter(j);
+    if (!T.length) return;
+    let A2 = c ? p.get(c) : void 0, $ = (b ? M[b] : void 0)?.rawValues || /* @__PURE__ */ new Set(), k = [...$].sort((V, oe) => V.localeCompare(oe));
+    for (let V of T) {
+      let oe = V.value !== "" && !$.has(V.value);
+      for (let X of [...V.options]) X.value !== "" && X.remove();
+      for (let X of k) {
+        let W = document.createElement("option");
+        W.value = X, W.textContent = X, V.append(W);
+      }
+      V === A2 && oe && A(V, ["input", "change"]);
+    }
+  }, E = watch([() => q2(e, i)?.fieldKey, () => q2(e, i)?.op, e.allFieldsData], (0, import_just_debounce.default)(L, 0), { immediate: true }), S = watch([() => q2(e, i)?.fieldKey, e.allFieldsData], (0, import_just_debounce.default)(h, 0), { immediate: true }), C = watch(() => q2(e, i)?.value, (b, M) => {
+    if (!e.readingFilters) {
+      b ?? (b = Array.isArray(M) ? [] : "");
+      for (let T of p.values()) Vo(T, b, ne);
+    }
+  });
+  return () => {
+    for (let b of f) b();
+    E(), S(), C();
+  };
+};
+var Dt2 = (e) => {
+  let t = e.type, n;
+  switch (t) {
+    case "select-multiple": {
+      n = [...e.selectedOptions].map((i) => i.value).filter(Boolean);
+      break;
+    }
+    case "date":
+    case "month":
+    case "week":
+    case "time": {
+      let { valueAsDate: i, value: a } = e;
+      n = i ? i.toISOString() : a;
+      break;
+    }
+    default:
+      n = e.value;
+  }
+  return n;
+};
+var q2 = (e, t) => {
+  let n = ue(e, t.conditionGroup);
+  if (n) return n.conditions.find((i) => i.id === t.id);
+};
+var Je = (e, t, n) => {
+  let i = v("condition-field", { scope: t });
+  if (!j(i)) return;
+  let a = v("condition-operator", { scope: t });
+  if (!j(a)) return;
+  let o = v("condition-value", { scope: t });
+  if (!on(o)) return;
+  let r = crypto.randomUUID(), s = /* @__PURE__ */ new Set(), l = { id: r, element: t, conditionGroup: n, cleanup: () => {
+    for (let x of s) x();
+    s.clear(), t.remove(), n.conditions.value = n.conditions.value.filter((x) => x.id !== r);
+    let T = ue(e, n);
+    if (!T) return;
+    let A2 = T.conditions.findIndex((x) => x.id === r);
+    A2 !== -1 && T.conditions.splice(A2, 1);
+  } }, u = i.value, d = o.type, p = Dt2(o), c = y(o, "fuzzy"), m = y(o, "tagvalues", { filterInvalid: true }) ?? D.tagvalues.defaultValue, { op: f, fieldMatch: L } = Ie(a.value);
+  n.conditions.value = [...n.conditions.value, l];
+  let h = ue(e, n);
+  if (!h) return;
+  h.conditions.push({ id: r, type: d, fieldKey: u, op: f, value: p, fuzzyThreshold: c, fieldMatch: L, showTag: true, interacted: true, tagValuesDisplay: m });
+  let E = v("condition-remove", { scope: t });
+  if (E) {
+    let T = kr(E, l, n);
+    s.add(T);
+  }
+  let S = Pr(e, i, l);
+  s.add(S);
+  let C = Fr(e, a, l);
+  s.add(C);
+  let b = Rr(e, o, t, l);
+  s.add(b);
+  let M = watch(() => q2(e, l), (T) => {
+    T || l.cleanup();
+  });
+  return s.add(M), l;
+};
+var Ot = (e, t, n) => {
+  let i = kn(t, "change", () => {
+    e.filters.value.groupsMatch = ie2(t);
+  }), a = y(t, "dynamicdisabledclass"), o = effect(() => {
+    let r = n.value.length <= 1;
+    t.setAttribute("aria-disabled", r ? "true" : "false"), t.classList.toggle(a, r);
+  });
+  return () => {
+    i(), o.effect.stop();
+  };
+};
+var Ht2 = (e, t, n, i, a) => kn(t, "click", () => {
+  let r = F(n), s = tt(e, r, a);
+  if (!s) return;
+  let l = a.value[a.value.length - 2];
+  l ? l.element.after(s.element) : i.append(s.element);
+});
+var _r = (e, t, n) => {
+  let i = kn(e, "click", () => {
+    n.value.length <= 1 || t.cleanup();
+  }), a = y(e, "dynamicdisabledclass"), o = effect(() => {
+    let r = n.value.length <= 1;
+    e.setAttribute("aria-disabled", r ? "true" : "false"), e.classList.toggle(a, r);
+  });
+  return () => {
+    i(), o.effect.stop();
+  };
+};
+var ue = (e, t) => e.filters.value.groups.find((n) => n.id === t.id);
+var tt = (e, t, n) => {
+  let i = v("condition", { scope: t });
+  if (!i) return;
+  let a = F(i), o = crypto.randomUUID(), r = /* @__PURE__ */ new Set(), s = { id: o, element: t, conditions: shallowRef([]), cleanup: () => {
+    for (let f of s.conditions.value) f.cleanup();
+    for (let f of r) f();
+    r.clear(), t.remove(), n.value = n.value.filter((f) => f.id !== o);
+    let m = e.filters.value.groups.findIndex((f) => f.id === o);
+    m !== -1 && e.filters.value.groups.splice(m, 1);
+  } }, l = "and", u = v("condition-match", { scope: t });
+  if (u) {
+    l = ie2(u);
+    let m = Ft2(e, u, s);
+    r.add(m);
+  }
+  n.value = [...n.value, s], e.filters.value.groups.push({ id: o, conditionsMatch: l, conditions: [] });
+  let d = v("condition-add", { scope: t });
+  if (d) {
+    let m = Rt(e, d, a, s);
+    r.add(m);
+  }
+  let p = v("condition-group-remove", { scope: t });
+  if (p) {
+    let m = _r(p, s, n);
+    r.add(m);
+  }
+  Je(e, i, s);
+  let c = watch(() => ue(e, s), (m) => {
+    m || s.cleanup();
+  });
+  return r.add(c), s;
+};
+var Nt2 = (e, t) => {
+  let n = v("condition-group", { scope: t });
+  if (!n) return;
+  let i = n.parentElement;
+  if (!i) return;
+  let a = F(n), o = shallowRef([]), r = /* @__PURE__ */ new Set(), s = Me(t);
+  r.add(s);
+  let l = v("condition-group-add", { scope: t }) || v("condition-groups-add", { scope: t });
+  if (l) {
+    let c = Ht2(e, l, a, i, o);
+    r.add(c);
+  }
+  let u = "and", d = v("condition-group-match", { scope: t }) || v("condition-groups-match", { scope: t });
+  if (d) {
+    u = ie2(d);
+    let c = Ot(e, d, o);
+    r.add(c);
+  }
+  e.filters.value.groupsMatch = u;
+  let p = Br(e);
+  return r.add(p), tt(e, n, o), () => {
+    for (let c of o.value) c.cleanup();
+    for (let c of r) c();
+    r.clear();
+  };
+};
+var Br = (e) => kn(window, "click", (t) => {
+  let { target: n } = t;
+  if (!(n instanceof Element)) return;
+  let { instance: i, filters: a } = e, o = I("clear", { instance: i });
+  if (!n?.closest(o)) return;
+  e.settingFilters = true, a.value.groups.splice(1);
+  let s = a.value.groups[0];
+  if (!s) return;
+  s.conditions.splice(1);
+  let l = s.conditions[0];
+  if (!l) return;
+  let u = { value: Array.isArray(l.value) ? [] : "", interacted: false };
+  Object.assign(l, u), e.settingFilters = false;
+});
+function nt() {
+  return inlineWorker('var Bo=Object.create;var Hr=Object.defineProperty,Oo=Object.defineProperties,Fo=Object.getOwnPropertyDescriptor,Lo=Object.getOwnPropertyDescriptors,ko=Object.getOwnPropertyNames,or=Object.getOwnPropertySymbols,Po=Object.getPrototypeOf,zr=Object.prototype.hasOwnProperty,On=Object.prototype.propertyIsEnumerable;var Bn=(t,e,r)=>e in t?Hr(t,e,{enumerable:!0,configurable:!0,writable:!0,value:r}):t[e]=r,b=(t,e)=>{for(var r in e||(e={}))zr.call(e,r)&&Bn(t,r,e[r]);if(or)for(var r of or(e))On.call(e,r)&&Bn(t,r,e[r]);return t},O=(t,e)=>Oo(t,Lo(e));var X=(t,e)=>{var r={};for(var n in t)zr.call(t,n)&&e.indexOf(n)<0&&(r[n]=t[n]);if(t!=null&&or)for(var n of or(t))e.indexOf(n)<0&&On.call(t,n)&&(r[n]=t[n]);return r};var No=(t,e)=>()=>(e||t((e={exports:{}}).exports,e),e.exports);var Ko=(t,e,r,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let i of ko(e))!zr.call(t,i)&&i!==r&&Hr(t,i,{get:()=>e[i],enumerable:!(n=Fo(e,i))||n.enumerable});return t};var Uo=(t,e,r)=>(r=t!=null?Bo(Po(t)):{},Ko(e||!t||!t.__esModule?Hr(r,"default",{value:t,enumerable:!0}):r,t));var _o=No((Mo,Yr)=>{((t,e)=>{typeof define=="function"&&define.amd?define([],e):typeof Yr=="object"&&Yr.exports?Yr.exports=e():t.fuzzysort=e()})(Mo,t=>{"use strict";var e=(p,u)=>{if(!p||!u)return H;var h=d(p);xe(u)||(u=g(u));var w=h.bitflags;return(w&u._bitflags)!==w?H:A(h,u)},r=(p,u,h)=>{if(!p)return h!=null&&h.all?R(u,h):Et;var w=d(p),V=w.bitflags,T=w.containsSpace,x=f((h==null?void 0:h.threshold)||0),_=(h==null?void 0:h.limit)||rr,E=0,L=0,G=u.length;function he(ze){E<_?(He.add(ze),++E):(++L,ze._score>He.peek()._score&&He.replaceTop(ze))}if(h!=null&&h.key)for(var ae=h.key,W=0;W<G;++W){var me=u[W],Y=Le(me,ae);if(Y&&(xe(Y)||(Y=g(Y)),(V&Y._bitflags)===V)){var z=A(w,Y);z!==H&&(z._score<x||(z.obj=me,he(z)))}}else if(h!=null&&h.keys){var ke=h.keys,Se=ke.length;e:for(var W=0;W<G;++W){var me=u[W];{for(var le=0,$=0;$<Se;++$){var ae=ke[$],Y=Le(me,ae);if(!Y){be[$]=ne;continue}xe(Y)||(Y=g(Y)),be[$]=Y,le|=Y._bitflags}if((V&le)!==V)continue}if(T)for(let q=0;q<w.spaceSearches.length;q++)N[q]=de;for(var $=0;$<Se;++$){if(Y=be[$],Y===ne){re[$]=ne;continue}if(re[$]=A(w,Y,!1,T),re[$]===H){re[$]=ne;continue}if(T)for(let j=0;j<w.spaceSearches.length;j++){if(k[j]>-1e3&&N[j]>de){var ie=(N[j]+k[j])/4;ie>N[j]&&(N[j]=ie)}k[j]>N[j]&&(N[j]=k[j])}}if(T){for(let q=0;q<w.spaceSearches.length;q++)if(N[q]===de)continue e}else{var U=!1;for(let q=0;q<Se;q++)if(re[q]._score!==de){U=!0;break}if(!U)continue}var ye=new a(Se);for(let q=0;q<Se;q++)ye[q]=re[q];if(T){var ee=0;for(let q=0;q<w.spaceSearches.length;q++)ee+=N[q]}else{var ee=de;for(let j=0;j<Se;j++){var z=ye[j];if(z._score>-1e3&&ee>de){var ie=(ee+z._score)/4;ie>ee&&(ee=ie)}z._score>ee&&(ee=z._score)}}if(ye.obj=me,ye._score=ee,h!=null&&h.scoreFn){if(ee=h.scoreFn(ye),!ee)continue;ee=f(ee),ye._score=ee}ee<x||he(ye)}}else for(var W=0;W<G;++W){var Y=u[W];if(Y&&(xe(Y)||(Y=g(Y)),(V&Y._bitflags)===V)){var z=A(w,Y);z!==H&&(z._score<x||he(z))}}if(E===0)return Et;for(var Pe=new Array(E),W=E-1;W>=0;--W)Pe[W]=He.poll();return Pe.total=E+L,Pe},n=(p,u="<b>",h="</b>")=>{for(var w=typeof u=="function"?u:void 0,V=p.target,T=V.length,x=p.indexes,_="",E=0,L=0,G=!1,he=[],ae=0;ae<T;++ae){var W=V[ae];if(x[L]===ae){if(++L,G||(G=!0,w?(he.push(_),_=""):_+=u),L===x.length){w?(_+=W,he.push(w(_,E++)),_="",he.push(V.substr(ae+1))):_+=W+h+V.substr(ae+1);break}}else G&&(G=!1,w?(he.push(w(_,E++)),_=""):_+=h);_+=W}return w?he:_},i=p=>{typeof p=="number"?p=""+p:typeof p!="string"&&(p="");var u=I(p);return l(p,{_targetLower:u._lower,_targetLowerCodes:u.lowerCodes,_bitflags:u.bitflags})},o=()=>{M.clear(),B.clear()};class s{get indexes(){return this._indexes.slice(0,this._indexes.len).sort((u,h)=>u-h)}set indexes(u){return this._indexes=u}highlight(u,h){return n(this,u,h)}get score(){return m(this._score)}set score(u){this._score=f(u)}}class a extends Array{get score(){return m(this._score)}set score(u){this._score=f(u)}}var l=(p,u)=>{var w,V,T,x,_,E,L;let h=new s;return h.target=p,h.obj=(w=u.obj)!=null?w:H,h._score=(V=u._score)!=null?V:de,h._indexes=(T=u._indexes)!=null?T:[],h._targetLower=(x=u._targetLower)!=null?x:"",h._targetLowerCodes=(_=u._targetLowerCodes)!=null?_:H,h._nextBeginningIndexes=(E=u._nextBeginningIndexes)!=null?E:H,h._bitflags=(L=u._bitflags)!=null?L:0,h},m=p=>p===de?0:p>1?p:Math.E**(((-p+1)**.04307-1)*-2),f=p=>p===0?de:p>1?p:1-Math.pow(Math.log(p)/-2+1,1/.04307),c=p=>{typeof p=="number"?p=""+p:typeof p!="string"&&(p=""),p=p.trim();var u=I(p),h=[];if(u.containsSpace){var w=p.split(/\\s+/);w=[...new Set(w)];for(var V=0;V<w.length;V++)if(w[V]!==""){var T=I(w[V]);h.push({lowerCodes:T.lowerCodes,_lower:w[V].toLowerCase(),containsSpace:!1})}}return{lowerCodes:u.lowerCodes,_lower:u._lower,containsSpace:u.containsSpace,bitflags:u.bitflags,spaceSearches:h}},g=p=>{if(p.length>999)return i(p);var u=M.get(p);return u!==void 0||(u=i(p),M.set(p,u)),u},d=p=>{if(p.length>999)return c(p);var u=B.get(p);return u!==void 0||(u=c(p),B.set(p,u)),u},R=(p,u)=>{var h=[];h.total=p.length;var w=(u==null?void 0:u.limit)||rr;if(u!=null&&u.key)for(var V=0;V<p.length;V++){var T=p[V],x=Le(T,u.key);if(x!=H){xe(x)||(x=g(x));var _=l(x.target,{_score:x._score,obj:T});if(h.push(_),h.length>=w)return h}}else if(u!=null&&u.keys)for(var V=0;V<p.length;V++){for(var T=p[V],E=new a(u.keys.length),L=u.keys.length-1;L>=0;--L){var x=Le(T,u.keys[L]);if(!x){E[L]=ne;continue}xe(x)||(x=g(x)),x._score=de,x._indexes.len=0,E[L]=x}if(E.obj=T,E._score=de,h.push(E),h.length>=w)return h}else for(var V=0;V<p.length;V++){var x=p[V];if(x!=H&&(xe(x)||(x=g(x)),x._score=de,x._indexes.len=0,h.push(x),h.length>=w))return h}return h},A=(p,u,h=!1,w=!1)=>{if(h===!1&&p.containsSpace)return C(p,u,w);for(var V=p._lower,T=p.lowerCodes,x=T[0],_=u._targetLowerCodes,E=T.length,L=_.length,W=0,G=0,he=0;;){var ae=x===_[G];if(ae){if(K[he++]=G,++W,W===E)break;x=T[W]}if(++G,G>=L)return H}var W=0,me=!1,Y=0,z=u._nextBeginningIndexes;z===H&&(z=u._nextBeginningIndexes=F(u.target)),G=K[0]===0?0:z[K[0]-1];var ke=0;if(G!==L)for(;;)if(G>=L){if(W<=0||(++ke,ke>200))break;--W;var Se=v[--Y];G=z[Se]}else{var ae=T[W]===_[G];if(ae){if(v[Y++]=G,++W,W===E){me=!0;break}++G}else G=z[G]}var le=E<=1?-1:u._targetLower.indexOf(V,K[0]),$=!!~le,ie=$?le===0||u._nextBeginningIndexes[le-1]===le:!1;if($&&!ie){for(var U=0;U<z.length;U=z[U])if(!(U<=le)){for(var ye=0;ye<E&&T[ye]===u._targetLowerCodes[U+ye];ye++);if(ye===E){le=U,ie=!0;break}}}var ee=q=>{for(var j=0,Dn=0,_e=1;_e<E;++_e)q[_e]-q[_e-1]!==1&&(j-=q[_e],++Dn);var Do=q[E-1]-q[0]-(E-1);if(j-=(12+Do)*Dn,q[0]!==0&&(j-=q[0]*q[0]*.2),!me)j*=1e3;else{for(var qr=1,_e=z[0];_e<L;_e=z[_e])++qr;qr>24&&(j*=(qr-24)*10)}return j-=(L-E)/2,$&&(j/=1+E*E*1),ie&&(j/=1+E*E*1),j-=(L-E)/2,j};if(me)if(ie){for(var U=0;U<E;++U)K[U]=le+U;var Pe=K,ze=ee(K)}else var Pe=v,ze=ee(v);else{if($)for(var U=0;U<E;++U)K[U]=le+U;var Pe=K,ze=ee(Pe)}u._score=ze;for(var U=0;U<E;++U)u._indexes[U]=Pe[U];u._indexes.len=E;let ir=new s;return ir.target=u.target,ir._score=u._score,ir._indexes=u._indexes,ir},C=(p,u,h)=>{for(var w=new Set,V=0,T=H,x=0,_=p.spaceSearches,E=_.length,L=0,G=()=>{for(let ie=L-1;ie>=0;ie--)u._nextBeginningIndexes[P[ie*2+0]]=P[ie*2+1]},he=!1,$=0;$<E;++$){k[$]=de;var ae=_[$];if(T=A(ae,u),h){if(T===H)continue;he=!0}else if(T===H)return G(),H;var W=$===E-1;if(!W){var me=T._indexes,Y=!0;for(let U=0;U<me.len-1;U++)if(me[U+1]-me[U]!==1){Y=!1;break}if(Y){var z=me[me.len-1]+1,ke=u._nextBeginningIndexes[z-1];for(let U=z-1;U>=0&&ke===u._nextBeginningIndexes[U];U--)u._nextBeginningIndexes[U]=z,P[L*2+0]=U,P[L*2+1]=ke,L++}}V+=T._score/E,k[$]=T._score/E,T._indexes[0]<x&&(V-=(x-T._indexes[0])*2),x=T._indexes[0];for(var Se=0;Se<T._indexes.len;++Se)w.add(T._indexes[Se])}if(h&&!he)return H;G();var le=A(p,u,!0);if(le!==H&&le._score>V){if(h)for(var $=0;$<E;++$)k[$]=le._score/E;return le}h&&(T=u),T._score=V;var $=0;for(let ie of w)T._indexes[$++]=ie;return T._indexes.len=$,T},S=p=>p.replace(new RegExp("\\\\p{Script=Latin}+","gu"),u=>u.normalize("NFD")).replace(/[\\u0300-\\u036f]/g,""),I=p=>{p=S(p);for(var u=p.length,h=p.toLowerCase(),w=[],V=0,T=!1,x=0;x<u;++x){var _=w[x]=h.charCodeAt(x);if(_===32){T=!0;continue}var E=_>=97&&_<=122?_-97:_>=48&&_<=57?26:_<=127?30:31;V|=1<<E}return{lowerCodes:w,bitflags:V,containsSpace:T,_lower:h}},D=p=>{for(var u=p.length,h=[],w=0,V=!1,T=!1,x=0;x<u;++x){var _=p.charCodeAt(x),E=_>=65&&_<=90,L=E||_>=97&&_<=122||_>=48&&_<=57,G=E&&!V||!T||!L;V=E,T=L,G&&(h[w++]=x)}return h},F=p=>{p=S(p);for(var u=p.length,h=D(p),w=[],V=h[0],T=0,x=0;x<u;++x)V>x?w[x]=V:(V=h[++T],w[x]=V===void 0?u:V);return w},M=new Map,B=new Map,K=[],v=[],P=[],N=[],k=[],be=[],re=[],Le=(p,u)=>{var h=p[u];if(h!==void 0)return h;if(typeof u=="function")return u(p);var w=u;Array.isArray(u)||(w=u.split("."));for(var V=w.length,T=-1;p&&++T<V;)p=p[w[T]];return p},xe=p=>typeof p=="object"&&typeof p._bitflags=="number",rr=1/0,de=-rr,Et=[];Et.total=0;var H=null,ne=i(""),nr=p=>{var u=[],h=0,w={},V=T=>{for(var x=0,_=u[x],E=1;E<h;){var L=E+1;x=E,L<h&&u[L]._score<u[E]._score&&(x=L),u[x-1>>1]=u[x],E=1+(x<<1)}for(var G=x-1>>1;x>0&&_._score<u[G]._score;G=(x=G)-1>>1)u[x]=u[G];u[x]=_};return w.add=(T=>{var x=h;u[h++]=T;for(var _=x-1>>1;x>0&&T._score<u[_]._score;_=(x=_)-1>>1)u[x]=u[_];u[x]=T}),w.poll=(T=>{if(h!==0){var x=u[0];return u[0]=u[--h],V(),x}}),w.peek=(T=>{if(h!==0)return u[0]}),w.replaceTop=(T=>{u[0]=T,V()}),w},He=nr();return{single:e,go:r,prepare:i,cleanup:o}})});function jr(t,e){t.indexOf(e)===-1&&t.push(e)}function je(t,e){let r=t.indexOf(e);r>-1&&t.splice(r,1)}var fe=(t,e,r)=>r>e?e:r<t?t:r;var Ie=()=>{},ge=()=>{};var ue={};var wt=t=>/^-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)$/u.test(t);function Xr(t){return typeof t=="object"&&t!==null}var Vt=t=>/^0[^.\\s]+$/u.test(t);function Xe(t){let e;return()=>(e===void 0&&(e=t()),e)}var Te=t=>t;var Go=(t,e)=>r=>e(t(r)),Ze=(...t)=>t.reduce(Go);var Je=(t,e,r)=>{let n=e-t;return n===0?1:(r-t)/n};var Qe=class{constructor(){this.subscriptions=[]}add(e){return jr(this.subscriptions,e),()=>je(this.subscriptions,e)}notify(e,r,n){let i=this.subscriptions.length;if(i)if(i===1)this.subscriptions[0](e,r,n);else for(let o=0;o<i;o++){let s=this.subscriptions[o];s&&s(e,r,n)}}getSize(){return this.subscriptions.length}clear(){this.subscriptions.length=0}};var oe=t=>t*1e3,se=t=>t/1e3;function Mt(t,e){return e?t*(1e3/e):0}var Fn=(t,e,r)=>{let n=e-t;return((r-t)%n+n)%n+t};var Ln=(t,e,r)=>(((1-3*r+3*e)*t+(3*r-6*e))*t+3*e)*t,$o=1e-7,Wo=12;function Yo(t,e,r,n,i){let o,s,a=0;do s=e+(r-e)/2,o=Ln(s,n,i)-t,o>0?r=s:e=s;while(Math.abs(o)>$o&&++a<Wo);return s}function Ne(t,e,r,n){if(t===e&&r===n)return Te;let i=o=>Yo(o,0,1,t,r);return o=>o===0||o===1?o:Ln(i(o),e,n)}var sr=t=>e=>e<=.5?t(2*e)/2:(2-t(2*(1-e)))/2;var ar=t=>e=>1-t(1-e);var lr=Ne(.33,1.53,.69,.99),st=ar(lr),_t=sr(st);var It=t=>(t*=2)<1?.5*st(t):.5*(2-Math.pow(2,-10*(t-1)));var Ct=t=>1-Math.sin(Math.acos(t)),Zr=ar(Ct),Rt=sr(Ct);var Jr=Ne(.42,0,1,1),Qr=Ne(0,0,.58,1),Dt=Ne(.42,0,.58,1);var Bt=t=>Array.isArray(t)&&typeof t[0]!="number";function Ot(t,e){return Bt(t)?t[Fn(0,t.length,e)]:t}var Ft=t=>Array.isArray(t)&&typeof t[0]=="number";var kn={linear:Te,easeIn:Jr,easeInOut:Dt,easeOut:Qr,circIn:Ct,circInOut:Rt,circOut:Zr,backIn:st,backInOut:_t,backOut:lr,anticipate:It},qo=t=>typeof t=="string",at=t=>{if(Ft(t)){ge(t.length===4,"Cubic bezier arrays must contain four numerical values.","cubic-bezier-length");let[e,r,n,i]=t;return Ne(e,r,n,i)}else if(qo(t))return ge(kn[t]!==void 0,`Invalid easing type \'${t}\'`,"invalid-easing-type"),kn[t];return t};var Lt=["setup","read","resolveKeyframes","preUpdate","update","preRender","render","postRender"];var lt={value:null,addProjectionMetrics:null};function Pn(t,e){let r=new Set,n=new Set,i=!1,o=!1,s=new WeakSet,a={delta:0,timestamp:0,isProcessing:!1},l=0;function m(c){s.has(c)&&(f.schedule(c),t()),l++,c(a)}let f={schedule:(c,g=!1,d=!1)=>{let A=d&&i?r:n;return g&&s.add(c),A.has(c)||A.add(c),c},cancel:c=>{n.delete(c),s.delete(c)},process:c=>{if(a=c,i){o=!0;return}i=!0,[r,n]=[n,r],r.forEach(m),e&&lt.value&&lt.value.frameloop[e].push(l),l=0,r.clear(),i=!1,o&&(o=!1,f.process(c))}};return f}var Ho=40;function fr(t,e){let r=!1,n=!0,i={delta:0,timestamp:0,isProcessing:!1},o=()=>r=!0,s=Lt.reduce((D,F)=>(D[F]=Pn(o,e?F:void 0),D),{}),{setup:a,read:l,resolveKeyframes:m,preUpdate:f,update:c,preRender:g,render:d,postRender:R}=s,A=()=>{let D=ue.useManualTiming?i.timestamp:performance.now();r=!1,ue.useManualTiming||(i.delta=n?1e3/60:Math.max(Math.min(D-i.timestamp,Ho),1)),i.timestamp=D,i.isProcessing=!0,a.process(i),l.process(i),m.process(i),f.process(i),c.process(i),g.process(i),d.process(i),R.process(i),i.isProcessing=!1,r&&e&&(n=!1,t(A))},C=()=>{r=!0,n=!0,i.isProcessing||t(A)};return{schedule:Lt.reduce((D,F)=>{let M=s[F];return D[F]=(B,K=!1,v=!1)=>(r||C(),M.schedule(B,K,v)),D},{}),cancel:D=>{for(let F=0;F<Lt.length;F++)s[Lt[F]].cancel(D)},state:i,steps:s}}var{schedule:ce,cancel:kt,state:ft,steps:Af}=fr(typeof requestAnimationFrame!="undefined"?requestAnimationFrame:Te,!0);var ur;function zo(){ur=void 0}var te={now:()=>(ur===void 0&&te.set(ft.isProcessing||ue.useManualTiming?ft.timestamp:performance.now()),ur),set:t=>{ur=t,queueMicrotask(zo)}};var ut={layout:0,mainThread:0,waapi:0};var Nn=t=>e=>typeof e=="string"&&e.startsWith(t),mr=Nn("--"),jo=Nn("var(--"),mt=t=>jo(t)?Xo.test(t.split("/*")[0].trim()):!1,Xo=/var\\(--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)$/iu;function en(t){return typeof t!="string"?!1:t.split("/*")[0].includes("var(--")}var Ee={test:t=>typeof t=="number",parse:parseFloat,transform:t=>t},Ce=O(b({},Ee),{transform:t=>fe(0,1,t)}),Pt=O(b({},Ee),{default:1});var Ke=t=>Math.round(t*1e5)/1e5;var ct=/-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/gu;function Kn(t){return t==null}var Un=/^(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))$/iu;var pt=(t,e)=>r=>!!(typeof r=="string"&&Un.test(r)&&r.startsWith(t)||e&&!Kn(r)&&Object.prototype.hasOwnProperty.call(r,e)),cr=(t,e,r)=>n=>{if(typeof n!="string")return n;let[i,o,s,a]=n.match(ct);return{[t]:parseFloat(i),[e]:parseFloat(o),[r]:parseFloat(s),alpha:a!==void 0?parseFloat(a):1}};var Zo=t=>fe(0,255,t),tn=O(b({},Ee),{transform:t=>Math.round(Zo(t))}),we={test:pt("rgb","red"),parse:cr("red","green","blue"),transform:({red:t,green:e,blue:r,alpha:n=1})=>"rgba("+tn.transform(t)+", "+tn.transform(e)+", "+tn.transform(r)+", "+Ke(Ce.transform(n))+")"};function Jo(t){let e="",r="",n="",i="";return t.length>5?(e=t.substring(1,3),r=t.substring(3,5),n=t.substring(5,7),i=t.substring(7,9)):(e=t.substring(1,2),r=t.substring(2,3),n=t.substring(3,4),i=t.substring(4,5),e+=e,r+=r,n+=n,i+=i),{red:parseInt(e,16),green:parseInt(r,16),blue:parseInt(n,16),alpha:i?parseInt(i,16)/255:1}}var Nt={test:pt("#"),parse:Jo,transform:we.transform};var Kt=t=>({test:e=>typeof e=="string"&&e.endsWith(t)&&e.split(" ").length===1,parse:parseFloat,transform:e=>`${e}${t}`}),Ve=Kt("deg"),Ue=Kt("%"),y=Kt("px"),Gn=Kt("vh"),$n=Kt("vw"),rn=O(b({},Ue),{parse:t=>Ue.parse(t)/100,transform:t=>Ue.transform(t*100)});var Ge={test:pt("hsl","hue"),parse:cr("hue","saturation","lightness"),transform:({hue:t,saturation:e,lightness:r,alpha:n=1})=>"hsla("+Math.round(t)+", "+Ue.transform(Ke(e))+", "+Ue.transform(Ke(r))+", "+Ke(Ce.transform(n))+")"};var Q={test:t=>we.test(t)||Nt.test(t)||Ge.test(t),parse:t=>we.test(t)?we.parse(t):Ge.test(t)?Ge.parse(t):Nt.parse(t),transform:t=>typeof t=="string"?t:t.hasOwnProperty("red")?we.transform(t):Ge.transform(t),getAnimatableNone:t=>{let e=Q.parse(t);return e.alpha=0,Q.transform(e)}};var Wn=/(?:#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\))/giu;function Qo(t){var e,r;return isNaN(t)&&typeof t=="string"&&(((e=t.match(ct))==null?void 0:e.length)||0)+(((r=t.match(Wn))==null?void 0:r.length)||0)>0}var qn="number",Hn="color",es="var",ts="var(",Yn="${}",rs=/var\\s*\\(\\s*--(?:[\\w-]+\\s*|[\\w-]+\\s*,(?:\\s*[^)(\\s]|\\s*\\((?:[^)(]|\\([^)(]*\\))*\\))+\\s*)\\)|#[\\da-f]{3,8}|(?:rgb|hsl)a?\\((?:-?[\\d.]+%?[,\\s]+){2}-?[\\d.]+%?\\s*(?:[,/]\\s*)?(?:\\b\\d+(?:\\.\\d+)?|\\.\\d+)?%?\\)|-?(?:\\d+(?:\\.\\d+)?|\\.\\d+)/giu;function et(t){let e=t.toString(),r=[],n={color:[],number:[],var:[]},i=[],o=0,a=e.replace(rs,l=>(Q.test(l)?(n.color.push(o),i.push(Hn),r.push(Q.parse(l))):l.startsWith(ts)?(n.var.push(o),i.push(es),r.push(l)):(n.number.push(o),i.push(qn),r.push(parseFloat(l))),++o,Yn)).split(Yn);return{values:r,split:a,indexes:n,types:i}}function zn(t){return et(t).values}function jn(t){let{split:e,types:r}=et(t),n=e.length;return i=>{let o="";for(let s=0;s<n;s++)if(o+=e[s],i[s]!==void 0){let a=r[s];a===qn?o+=Ke(i[s]):a===Hn?o+=Q.transform(i[s]):o+=i[s]}return o}}var ns=t=>typeof t=="number"?0:Q.test(t)?Q.getAnimatableNone(t):t;function is(t){let e=zn(t);return jn(t)(e.map(ns))}var pe={test:Qo,parse:zn,createTransformer:jn,getAnimatableNone:is};function nn(t,e,r){return r<0&&(r+=1),r>1&&(r-=1),r<1/6?t+(e-t)*6*r:r<1/2?e:r<2/3?t+(e-t)*(2/3-r)*6:t}function Xn({hue:t,saturation:e,lightness:r,alpha:n}){t/=360,e/=100,r/=100;let i=0,o=0,s=0;if(!e)i=o=s=r;else{let a=r<.5?r*(1+e):r+e-r*e,l=2*r-a;i=nn(l,a,t+1/3),o=nn(l,a,t),s=nn(l,a,t-1/3)}return{red:Math.round(i*255),green:Math.round(o*255),blue:Math.round(s*255),alpha:n}}function dt(t,e){return r=>r>0?e:t}var ve=(t,e,r)=>t+(e-t)*r;var on=(t,e,r)=>{let n=t*t,i=r*(e*e-n)+n;return i<0?0:Math.sqrt(i)},os=[Nt,we,Ge],ss=t=>os.find(e=>e.test(t));function Zn(t){let e=ss(t);if(Ie(!!e,`\'${t}\' is not an animatable color. Use the equivalent color code instead.`,"color-not-animatable"),!e)return!1;let r=e.parse(t);return e===Ge&&(r=Xn(r)),r}var sn=(t,e)=>{let r=Zn(t),n=Zn(e);if(!r||!n)return dt(t,e);let i=b({},r);return o=>(i.red=on(r.red,n.red,o),i.green=on(r.green,n.green,o),i.blue=on(r.blue,n.blue,o),i.alpha=ve(r.alpha,n.alpha,o),we.transform(i))};var pr=new Set(["none","hidden"]);function Jn(t,e){return pr.has(t)?r=>r<=0?t:e:r=>r>=1?e:t}function as(t,e){return r=>ve(t,e,r)}function dr(t){return typeof t=="number"?as:typeof t=="string"?mt(t)?dt:Q.test(t)?sn:us:Array.isArray(t)?Qn:typeof t=="object"?Q.test(t)?sn:ls:dt}function Qn(t,e){let r=[...t],n=r.length,i=t.map((o,s)=>dr(o)(o,e[s]));return o=>{for(let s=0;s<n;s++)r[s]=i[s](o);return r}}function ls(t,e){let r=b(b({},t),e),n={};for(let i in r)t[i]!==void 0&&e[i]!==void 0&&(n[i]=dr(t[i])(t[i],e[i]));return i=>{for(let o in n)r[o]=n[o](i);return r}}function fs(t,e){var i;let r=[],n={color:0,var:0,number:0};for(let o=0;o<e.values.length;o++){let s=e.types[o],a=t.indexes[s][n[s]],l=(i=t.values[a])!=null?i:0;r[o]=l,n[s]++}return r}var us=(t,e)=>{let r=pe.createTransformer(e),n=et(t),i=et(e);return n.indexes.var.length===i.indexes.var.length&&n.indexes.color.length===i.indexes.color.length&&n.indexes.number.length>=i.indexes.number.length?pr.has(t)&&!i.values.length||pr.has(e)&&!n.values.length?Jn(t,e):Ze(Qn(fs(n,i),i.values),r):(Ie(!0,`Complex values \'${t}\' and \'${e}\' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`,"complex-values-different"),dt(t,e))};function hr(t,e,r){return typeof t=="number"&&typeof e=="number"&&typeof r=="number"?ve(t,e,r):dr(t)(t,e)}var ei=t=>{let e=({timestamp:r})=>t(r);return{start:(r=!0)=>ce.update(e,r),stop:()=>kt(e),now:()=>ft.isProcessing?ft.timestamp:te.now()}};var gr=(t,e,r=10)=>{let n="",i=Math.max(Math.round(e/r),2);for(let o=0;o<i;o++)n+=Math.round(t(o/(i-1))*1e4)/1e4+", ";return`linear(${n.substring(0,n.length-2)})`};function ht(t){let e=0,r=50,n=t.next(e);for(;!n.done&&e<2e4;)e+=r,n=t.next(e);return e>=2e4?1/0:e}function Ut(t,e=100,r){let n=r(O(b({},t),{keyframes:[0,e]})),i=Math.min(ht(n),2e4);return{type:"keyframes",ease:o=>n.next(i*o).value/e,duration:se(i)}}var ms=5;function xr(t,e,r){let n=Math.max(e-ms,0);return Mt(r-t(n),e-n)}var Z={stiffness:100,damping:10,mass:1,velocity:0,duration:800,bounce:.3,visualDuration:.3,restSpeed:{granular:.01,default:2},restDelta:{granular:.005,default:.5},minDuration:.01,maxDuration:10,minDamping:.05,maxDamping:1};var ln=.001;function ti({duration:t=Z.duration,bounce:e=Z.bounce,velocity:r=Z.velocity,mass:n=Z.mass}){let i,o;Ie(t<=oe(Z.maxDuration),"Spring duration must be 10 seconds or less","spring-duration-limit");let s=1-e;s=fe(Z.minDamping,Z.maxDamping,s),t=fe(Z.minDuration,Z.maxDuration,se(t)),s<1?(i=m=>{let f=m*s,c=f*t,g=f-r,d=yr(m,s),R=Math.exp(-c);return ln-g/d*R},o=m=>{let c=m*s*t,g=c*r+r,d=Math.pow(s,2)*Math.pow(m,2)*t,R=Math.exp(-c),A=yr(Math.pow(m,2),s);return(-i(m)+ln>0?-1:1)*((g-d)*R)/A}):(i=m=>{let f=Math.exp(-m*t),c=(m-r)*t+1;return-ln+f*c},o=m=>{let f=Math.exp(-m*t),c=(r-m)*(t*t);return f*c});let a=5/t,l=ps(i,o,a);if(t=oe(t),isNaN(l))return{stiffness:Z.stiffness,damping:Z.damping,duration:t};{let m=Math.pow(l,2)*n;return{stiffness:m,damping:s*2*Math.sqrt(n*m),duration:t}}}var cs=12;function ps(t,e,r){let n=r;for(let i=1;i<cs;i++)n=n-t(n)/e(n);return n}function yr(t,e){return t*Math.sqrt(1-e*e)}var ds=["duration","bounce"],hs=["stiffness","damping","mass"];function ri(t,e){return e.some(r=>t[r]!==void 0)}function gs(t){let e=b({velocity:Z.velocity,stiffness:Z.stiffness,damping:Z.damping,mass:Z.mass,isResolvedFromDuration:!1},t);if(!ri(t,hs)&&ri(t,ds))if(t.visualDuration){let r=t.visualDuration,n=2*Math.PI/(r*1.2),i=n*n,o=2*fe(.05,1,1-(t.bounce||0))*Math.sqrt(i);e=O(b({},e),{mass:Z.mass,stiffness:i,damping:o})}else{let r=ti(t);e=O(b(b({},e),r),{mass:Z.mass}),e.isResolvedFromDuration=!0}return e}function Re(t=Z.visualDuration,e=Z.bounce){let r=typeof t!="object"?{visualDuration:t,keyframes:[0,1],bounce:e}:t,{restSpeed:n,restDelta:i}=r,o=r.keyframes[0],s=r.keyframes[r.keyframes.length-1],a={done:!1,value:o},{stiffness:l,damping:m,mass:f,duration:c,velocity:g,isResolvedFromDuration:d}=gs(O(b({},r),{velocity:-se(r.velocity||0)})),R=g||0,A=m/(2*Math.sqrt(l*f)),C=s-o,S=se(Math.sqrt(l/f)),I=Math.abs(C)<5;n||(n=I?Z.restSpeed.granular:Z.restSpeed.default),i||(i=I?Z.restDelta.granular:Z.restDelta.default);let D;if(A<1){let M=yr(S,A);D=B=>{let K=Math.exp(-A*S*B);return s-K*((R+A*S*C)/M*Math.sin(M*B)+C*Math.cos(M*B))}}else if(A===1)D=M=>s-Math.exp(-S*M)*(C+(R+S*C)*M);else{let M=S*Math.sqrt(A*A-1);D=B=>{let K=Math.exp(-A*S*B),v=Math.min(M*B,300);return s-K*((R+A*S*C)*Math.sinh(v)+M*C*Math.cosh(v))/M}}let F={calculatedDuration:d&&c||null,next:M=>{let B=D(M);if(d)a.done=M>=c;else{let K=M===0?R:0;A<1&&(K=M===0?oe(R):xr(D,M,B));let v=Math.abs(K)<=n,P=Math.abs(s-B)<=i;a.done=v&&P}return a.value=a.done?s:B,a},toString:()=>{let M=Math.min(ht(F),2e4),B=gr(K=>F.next(M*K).value,M,30);return M+"ms "+B},toTransition:()=>{}};return F}Re.applyToOptions=t=>{let e=Ut(t,100,Re);return t.ease=e.ease,t.duration=oe(e.duration),t.type="keyframes",t};function Gt({keyframes:t,velocity:e=0,power:r=.8,timeConstant:n=325,bounceDamping:i=10,bounceStiffness:o=500,modifyTarget:s,min:a,max:l,restDelta:m=.5,restSpeed:f}){let c=t[0],g={done:!1,value:c},d=v=>a!==void 0&&v<a||l!==void 0&&v>l,R=v=>a===void 0?l:l===void 0||Math.abs(a-v)<Math.abs(l-v)?a:l,A=r*e,C=c+A,S=s===void 0?C:s(C);S!==C&&(A=S-c);let I=v=>-A*Math.exp(-v/n),D=v=>S+I(v),F=v=>{let P=I(v),N=D(v);g.done=Math.abs(P)<=m,g.value=g.done?S:N},M,B,K=v=>{d(g.value)&&(M=v,B=Re({keyframes:[g.value,R(g.value)],velocity:xr(D,v,g.value),damping:i,stiffness:o,restDelta:m,restSpeed:f}))};return K(0),{calculatedDuration:null,next:v=>{let P=!1;return!B&&M===void 0&&(P=!0,F(v),K(v)),M!==void 0&&v>=M?B.next(v-M):(!P&&F(v),g)}}}function xs(t,e,r){let n=[],i=r||ue.mix||hr,o=t.length-1;for(let s=0;s<o;s++){let a=i(t[s],t[s+1]);if(e){let l=Array.isArray(e)?e[s]||Te:e;a=Ze(l,a)}n.push(a)}return n}function ni(t,e,{clamp:r=!0,ease:n,mixer:i}={}){let o=t.length;if(ge(o===e.length,"Both input and output ranges must be the same length","range-length"),o===1)return()=>e[0];if(o===2&&e[0]===e[1])return()=>e[1];let s=t[0]===t[1];t[0]>t[o-1]&&(t=[...t].reverse(),e=[...e].reverse());let a=xs(e,n,i),l=a.length,m=f=>{if(s&&f<t[0])return e[0];let c=0;if(l>1)for(;c<t.length-2&&!(f<t[c+1]);c++);let g=Je(t[c],t[c+1],f);return a[c](g)};return r?f=>m(fe(t[0],t[o-1],f)):m}function $t(t,e){let r=t[t.length-1];for(let n=1;n<=e;n++){let i=Je(0,e,n);t.push(ve(r,1,i))}}function Wt(t){let e=[0];return $t(e,t.length-1),e}function ii(t,e){return t.map(r=>r*e)}function ys(t,e){return t.map(()=>e||Dt).splice(0,t.length-1)}function tt({duration:t=300,keyframes:e,times:r,ease:n="easeInOut"}){let i=Bt(n)?n.map(at):at(n),o={done:!1,value:e[0]},s=ii(r&&r.length===e.length?r:Wt(e),t),a=ni(s,e,{ease:Array.isArray(i)?i:ys(e,i)});return{calculatedDuration:t,next:l=>(o.value=a(l),o.done=l>=t,o)}}var Ts=t=>t!==null;function gt(t,{repeat:e,repeatType:r="loop"},n,i=1){let o=t.filter(Ts),a=i<0||e&&r!=="loop"&&e%2===1?0:o.length-1;return!a||n===void 0?o[a]:n}var vs={decay:Gt,inertia:Gt,tween:tt,keyframes:tt,spring:Re};function Tr(t){typeof t.type=="string"&&(t.type=vs[t.type])}var $e=class{constructor(){this.updateFinished()}get finished(){return this._finished}updateFinished(){this._finished=new Promise(e=>{this.resolve=e})}notifyFinished(){this.resolve()}then(e,r){return this.finished.then(e,r)}};var bs=t=>t/100,We=class extends $e{constructor(e){super(),this.state="idle",this.startTime=null,this.isStopped=!1,this.currentTime=0,this.holdTime=null,this.playbackSpeed=1,this.stop=()=>{var n,i;let{motionValue:r}=this.options;r&&r.updatedAt!==te.now()&&this.tick(te.now()),this.isStopped=!0,this.state!=="idle"&&(this.teardown(),(i=(n=this.options).onStop)==null||i.call(n))},ut.mainThread++,this.options=e,this.initAnimation(),this.play(),e.autoplay===!1&&this.pause()}initAnimation(){let{options:e}=this;Tr(e);let{type:r=tt,repeat:n=0,repeatDelay:i=0,repeatType:o,velocity:s=0}=e,{keyframes:a}=e,l=r||tt;l!==tt&&typeof a[0]!="number"&&(this.mixKeyframes=Ze(bs,hr(a[0],a[1])),a=[0,100]);let m=l(O(b({},e),{keyframes:a}));o==="mirror"&&(this.mirroredGenerator=l(O(b({},e),{keyframes:[...a].reverse(),velocity:-s}))),m.calculatedDuration===null&&(m.calculatedDuration=ht(m));let{calculatedDuration:f}=m;this.calculatedDuration=f,this.resolvedDuration=f+i,this.totalDuration=this.resolvedDuration*(n+1)-i,this.generator=m}updateTime(e){let r=Math.round(e-this.startTime)*this.playbackSpeed;this.holdTime!==null?this.currentTime=this.holdTime:this.currentTime=r}tick(e,r=!1){let{generator:n,totalDuration:i,mixKeyframes:o,mirroredGenerator:s,resolvedDuration:a,calculatedDuration:l}=this;if(this.startTime===null)return n.next(0);let{delay:m=0,keyframes:f,repeat:c,repeatType:g,repeatDelay:d,type:R,onUpdate:A,finalKeyframe:C}=this.options;this.speed>0?this.startTime=Math.min(this.startTime,e):this.speed<0&&(this.startTime=Math.min(e-i/this.speed,this.startTime)),r?this.currentTime=e:this.updateTime(e);let S=this.currentTime-m*(this.playbackSpeed>=0?1:-1),I=this.playbackSpeed>=0?S<0:S>i;this.currentTime=Math.max(S,0),this.state==="finished"&&this.holdTime===null&&(this.currentTime=i);let D=this.currentTime,F=n;if(c){let v=Math.min(this.currentTime,i)/a,P=Math.floor(v),N=v%1;!N&&v>=1&&(N=1),N===1&&P--,P=Math.min(P,c+1),P%2&&(g==="reverse"?(N=1-N,d&&(N-=d/a)):g==="mirror"&&(F=s)),D=fe(0,1,N)*a}let M=I?{done:!1,value:f[0]}:F.next(D);o&&(M.value=o(M.value));let{done:B}=M;!I&&l!==null&&(B=this.playbackSpeed>=0?this.currentTime>=i:this.currentTime<=0);let K=this.holdTime===null&&(this.state==="finished"||this.state==="running"&&B);return K&&R!==Gt&&(M.value=gt(f,this.options,C,this.speed)),A&&A(M.value),K&&this.finish(),M}then(e,r){return this.finished.then(e,r)}get duration(){return se(this.calculatedDuration)}get iterationDuration(){let{delay:e=0}=this.options||{};return this.duration+se(e)}get time(){return se(this.currentTime)}set time(e){var r;e=oe(e),this.currentTime=e,this.startTime===null||this.holdTime!==null||this.playbackSpeed===0?this.holdTime=e:this.driver&&(this.startTime=this.driver.now()-e/this.playbackSpeed),(r=this.driver)==null||r.start(!1)}get speed(){return this.playbackSpeed}set speed(e){this.updateTime(te.now());let r=this.playbackSpeed!==e;this.playbackSpeed=e,r&&(this.time=se(this.currentTime))}play(){var i,o;if(this.isStopped)return;let{driver:e=ei,startTime:r}=this.options;this.driver||(this.driver=e(s=>this.tick(s))),(o=(i=this.options).onPlay)==null||o.call(i);let n=this.driver.now();this.state==="finished"?(this.updateFinished(),this.startTime=n):this.holdTime!==null?this.startTime=n-this.holdTime:this.startTime||(this.startTime=r!=null?r:n),this.state==="finished"&&this.speed<0&&(this.startTime+=this.calculatedDuration),this.holdTime=null,this.state="running",this.driver.start()}pause(){this.state="paused",this.updateTime(te.now()),this.holdTime=this.currentTime}complete(){this.state!=="running"&&this.play(),this.state="finished",this.holdTime=null}finish(){var e,r;this.notifyFinished(),this.teardown(),this.state="finished",(r=(e=this.options).onComplete)==null||r.call(e)}cancel(){var e,r;this.holdTime=null,this.startTime=0,this.tick(0),this.teardown(),(r=(e=this.options).onCancel)==null||r.call(e)}teardown(){this.state="idle",this.stopDriver(),this.startTime=this.holdTime=null,ut.mainThread--}stopDriver(){this.driver&&(this.driver.stop(),this.driver=void 0)}sample(e){return this.startTime=0,this.tick(e,!0)}attachTimeline(e){var r;return this.options.allowFlatten&&(this.options.type="keyframes",this.options.ease="linear",this.initAnimation()),(r=this.driver)==null||r.stop(),e.observe(this)}};function oi(t){var e;for(let r=1;r<t.length;r++)(e=t[r])!=null||(t[r]=t[r-1])}var rt=t=>t*180/Math.PI,fn=t=>{let e=rt(Math.atan2(t[1],t[0]));return un(e)},Ss={x:4,y:5,translateX:4,translateY:5,scaleX:0,scaleY:3,scale:t=>(Math.abs(t[0])+Math.abs(t[3]))/2,rotate:fn,rotateZ:fn,skewX:t=>rt(Math.atan(t[1])),skewY:t=>rt(Math.atan(t[2])),skew:t=>(Math.abs(t[1])+Math.abs(t[2]))/2},un=t=>(t=t%360,t<0&&(t+=360),t),si=fn,ai=t=>Math.sqrt(t[0]*t[0]+t[1]*t[1]),li=t=>Math.sqrt(t[4]*t[4]+t[5]*t[5]),As={x:12,y:13,z:14,translateX:12,translateY:13,translateZ:14,scaleX:ai,scaleY:li,scale:t=>(ai(t)+li(t))/2,rotateX:t=>un(rt(Math.atan2(t[6],t[5]))),rotateY:t=>un(rt(Math.atan2(-t[2],t[0]))),rotateZ:si,rotate:si,skewX:t=>rt(Math.atan(t[4])),skewY:t=>rt(Math.atan(t[1])),skew:t=>(Math.abs(t[1])+Math.abs(t[4]))/2};function vr(t){return t.includes("scale")?1:0}function br(t,e){if(!t||t==="none")return vr(e);let r=t.match(/^matrix3d\\(([-\\d.e\\s,]+)\\)$/u),n,i;if(r)n=As,i=r;else{let a=t.match(/^matrix\\(([-\\d.e\\s,]+)\\)$/u);n=Ss,i=a}if(!i)return vr(e);let o=n[e],s=i[1].split(",").map(Es);return typeof o=="function"?o(s):s[o]}var fi=(t,e)=>{let{transform:r="none"}=getComputedStyle(t);return br(r,e)};function Es(t){return parseFloat(t.trim())}var Me=["transformPerspective","x","y","z","translateX","translateY","translateZ","scale","scaleX","scaleY","rotate","rotateX","rotateY","rotateZ","skew","skewX","skewY"],Ae=new Set(Me);var mn=t=>t===Ee||t===y,ws=new Set(["x","y","z"]),Vs=Me.filter(t=>!ws.has(t));function ui(t){let e=[];return Vs.forEach(r=>{let n=t.getValue(r);n!==void 0&&(e.push([r,n.get()]),n.set(r.startsWith("scale")?1:0))}),e}var De={width:({x:t},{paddingLeft:e="0",paddingRight:r="0"})=>t.max-t.min-parseFloat(e)-parseFloat(r),height:({y:t},{paddingTop:e="0",paddingBottom:r="0"})=>t.max-t.min-parseFloat(e)-parseFloat(r),top:(t,{top:e})=>parseFloat(e),left:(t,{left:e})=>parseFloat(e),bottom:({y:t},{top:e})=>parseFloat(e)+(t.max-t.min),right:({x:t},{left:e})=>parseFloat(e)+(t.max-t.min),x:(t,{transform:e})=>br(e,"x"),y:(t,{transform:e})=>br(e,"y")};De.translateX=De.x;De.translateY=De.y;var nt=new Set,cn=!1,pn=!1,dn=!1;function mi(){if(pn){let t=Array.from(nt).filter(n=>n.needsMeasurement),e=new Set(t.map(n=>n.element)),r=new Map;e.forEach(n=>{let i=ui(n);i.length&&(r.set(n,i),n.render())}),t.forEach(n=>n.measureInitialState()),e.forEach(n=>{n.render();let i=r.get(n);i&&i.forEach(([o,s])=>{var a;(a=n.getValue(o))==null||a.set(s)})}),t.forEach(n=>n.measureEndState()),t.forEach(n=>{n.suspendedScrollY!==void 0&&window.scrollTo(0,n.suspendedScrollY)})}pn=!1,cn=!1,nt.forEach(t=>t.complete(dn)),nt.clear()}function ci(){nt.forEach(t=>{t.readKeyframes(),t.needsMeasurement&&(pn=!0)})}function pi(){dn=!0,ci(),mi(),dn=!1}var Ye=class{constructor(e,r,n,i,o,s=!1){this.state="pending",this.isAsync=!1,this.needsMeasurement=!1,this.unresolvedKeyframes=[...e],this.onComplete=r,this.name=n,this.motionValue=i,this.element=o,this.isAsync=s}scheduleResolve(){this.state="scheduled",this.isAsync?(nt.add(this),cn||(cn=!0,ce.read(ci),ce.resolveKeyframes(mi))):(this.readKeyframes(),this.complete())}readKeyframes(){let{unresolvedKeyframes:e,name:r,element:n,motionValue:i}=this;if(e[0]===null){let o=i==null?void 0:i.get(),s=e[e.length-1];if(o!==void 0)e[0]=o;else if(n&&r){let a=n.readValue(r,s);a!=null&&(e[0]=a)}e[0]===void 0&&(e[0]=s),i&&o===void 0&&i.set(e[0])}oi(e)}setFinalKeyframe(){}measureInitialState(){}renderEndStyles(){}measureEndState(){}complete(e=!1){this.state="complete",this.onComplete(this.unresolvedKeyframes,this.finalKeyframe,e),nt.delete(this)}cancel(){this.state==="scheduled"&&(nt.delete(this),this.state="pending")}resume(){this.state==="pending"&&this.scheduleResolve()}};var di=t=>t.startsWith("--");function hi(t,e,r){di(e)?t.style.setProperty(e,r):t.style[e]=r}var gi=Xe(()=>window.ScrollTimeline!==void 0);var xi={};function yi(t,e){let r=Xe(t);return()=>{var n;return(n=xi[e])!=null?n:r()}}var Sr=yi(()=>{try{document.createElement("div").animate({opacity:0},{easing:"linear(0, 1)"})}catch(t){return!1}return!0},"linearEasing");var it=([t,e,r,n])=>`cubic-bezier(${t}, ${e}, ${r}, ${n})`;var hn={linear:"linear",ease:"ease",easeIn:"ease-in",easeOut:"ease-out",easeInOut:"ease-in-out",circIn:it([0,.65,.55,1]),circOut:it([.55,0,1,.45]),backIn:it([.31,.01,.66,-.59]),backOut:it([.33,1.53,.69,.99])};function gn(t,e){if(t)return typeof t=="function"?Sr()?gr(t,e):"ease-out":Ft(t)?it(t):Array.isArray(t)?t.map(r=>gn(r,e)||hn.easeOut):hn[t]}function Ti(t,e,r,{delay:n=0,duration:i=300,repeat:o=0,repeatType:s="loop",ease:a="easeOut",times:l}={},m=void 0){let f={[e]:r};l&&(f.offset=l);let c=gn(a,i);Array.isArray(c)&&(f.easing=c),lt.value&&ut.waapi++;let g={delay:n,duration:i,easing:Array.isArray(c)?"linear":c,fill:"both",iterations:o+1,direction:s==="reverse"?"alternate":"normal"};m&&(g.pseudoElement=m);let d=t.animate(f,g);return lt.value&&d.finished.finally(()=>{ut.waapi--}),d}function ot(t){return typeof t=="function"&&"applyToOptions"in t}function vi(r){var n=r,{type:t}=n,e=X(n,["type"]);var i,o;return ot(t)&&Sr()?t.applyToOptions(e):((i=e.duration)!=null||(e.duration=300),(o=e.ease)!=null||(e.ease="easeOut"),e)}var Ar=class extends $e{constructor(e){if(super(),this.finishedTime=null,this.isStopped=!1,this.manualStartTime=null,!e)return;let{element:r,name:n,keyframes:i,pseudoElement:o,allowFlatten:s=!1,finalKeyframe:a,onComplete:l}=e;this.isPseudoElement=!!o,this.allowFlatten=s,this.options=e,ge(typeof e.type!="string",`Mini animate() doesn\'t support "type" as a string.`,"mini-spring");let m=vi(e);this.animation=Ti(r,n,i,m,o),m.autoplay===!1&&this.animation.pause(),this.animation.onfinish=()=>{if(this.finishedTime=this.time,!o){let f=gt(i,this.options,a,this.speed);this.updateMotionValue?this.updateMotionValue(f):hi(r,n,f),this.animation.cancel()}l==null||l(),this.notifyFinished()}}play(){this.isStopped||(this.manualStartTime=null,this.animation.play(),this.state==="finished"&&this.updateFinished())}pause(){this.animation.pause()}complete(){var e,r;(r=(e=this.animation).finish)==null||r.call(e)}cancel(){try{this.animation.cancel()}catch(e){}}stop(){if(this.isStopped)return;this.isStopped=!0;let{state:e}=this;e==="idle"||e==="finished"||(this.updateMotionValue?this.updateMotionValue():this.commitStyles(),this.isPseudoElement||this.cancel())}commitStyles(){var e,r;this.isPseudoElement||(r=(e=this.animation).commitStyles)==null||r.call(e)}get duration(){var r,n;let e=((n=(r=this.animation.effect)==null?void 0:r.getComputedTiming)==null?void 0:n.call(r).duration)||0;return se(Number(e))}get iterationDuration(){let{delay:e=0}=this.options||{};return this.duration+se(e)}get time(){return se(Number(this.animation.currentTime)||0)}set time(e){this.manualStartTime=null,this.finishedTime=null,this.animation.currentTime=oe(e)}get speed(){return this.animation.playbackRate}set speed(e){e<0&&(this.finishedTime=null),this.animation.playbackRate=e}get state(){return this.finishedTime!==null?"finished":this.animation.playState}get startTime(){var e;return(e=this.manualStartTime)!=null?e:Number(this.animation.startTime)}set startTime(e){this.manualStartTime=this.animation.startTime=e}attachTimeline({timeline:e,observe:r}){var n;return this.allowFlatten&&((n=this.animation.effect)==null||n.updateTiming({easing:"linear"})),this.animation.onfinish=null,e&&gi()?(this.animation.timeline=e,Te):r(this)}};var bi={anticipate:It,backInOut:_t,circInOut:Rt};function Ms(t){return t in bi}function Si(t){typeof t.ease=="string"&&Ms(t.ease)&&(t.ease=bi[t.ease])}var xn=10,Er=class extends Ar{constructor(e){Si(e),Tr(e),super(e),e.startTime!==void 0&&(this.startTime=e.startTime),this.options=e}updateMotionValue(e){let f=this.options,{motionValue:r,onUpdate:n,onComplete:i,element:o}=f,s=X(f,["motionValue","onUpdate","onComplete","element"]);if(!r)return;if(e!==void 0){r.set(e);return}let a=new We(O(b({},s),{autoplay:!1})),l=Math.max(xn,te.now()-this.startTime),m=fe(0,xn,l-xn);r.setWithVelocity(a.sample(Math.max(0,l-m)).value,a.sample(l).value,m),a.stop()}};var yn=(t,e)=>e==="zIndex"?!1:!!(typeof t=="number"||Array.isArray(t)||typeof t=="string"&&(pe.test(t)||t==="0")&&!t.startsWith("url("));function _s(t){let e=t[0];if(t.length===1)return!0;for(let r=0;r<t.length;r++)if(t[r]!==e)return!0}function Ai(t,e,r,n){let i=t[0];if(i===null)return!1;if(e==="display"||e==="visibility")return!0;let o=t[t.length-1],s=yn(i,e),a=yn(o,e);return Ie(s===a,`You are trying to animate ${e} from "${i}" to "${o}". "${s?o:i}" is not an animatable value.`,"value-not-animatable"),!s||!a?!1:_s(t)||(r==="spring"||ot(r))&&n}function Yt(t){t.duration=0,t.type="keyframes"}var Is=new Set(["opacity","clipPath","filter","transform"]),Cs=Xe(()=>Object.hasOwnProperty.call(Element.prototype,"animate"));function Ei(t){var f;let{motionValue:e,name:r,repeatDelay:n,repeatType:i,damping:o,type:s}=t;if(!(((f=e==null?void 0:e.owner)==null?void 0:f.current)instanceof HTMLElement))return!1;let{onUpdate:l,transformTemplate:m}=e.owner.getProps();return Cs()&&r&&Is.has(r)&&(r!=="transform"||!m)&&!l&&!n&&i!=="mirror"&&o!==0&&s!=="inertia"}var Rs=40,wr=class extends $e{constructor(g){var d=g,{autoplay:e=!0,delay:r=0,type:n="keyframes",repeat:i=0,repeatDelay:o=0,repeatType:s="loop",keyframes:a,name:l,motionValue:m,element:f}=d,c=X(d,["autoplay","delay","type","repeat","repeatDelay","repeatType","keyframes","name","motionValue","element"]);var C;super(),this.stop=()=>{var S,I;this._animation&&(this._animation.stop(),(S=this.stopTimeline)==null||S.call(this)),(I=this.keyframeResolver)==null||I.cancel()},this.createdAt=te.now();let R=b({autoplay:e,delay:r,type:n,repeat:i,repeatDelay:o,repeatType:s,name:l,motionValue:m,element:f},c),A=(f==null?void 0:f.KeyframeResolver)||Ye;this.keyframeResolver=new A(a,(S,I,D)=>this.onKeyframesResolved(S,I,R,!D),l,m,f),(C=this.keyframeResolver)==null||C.scheduleResolve()}onKeyframesResolved(e,r,n,i){var C,S;this.keyframeResolver=void 0;let{name:o,type:s,velocity:a,delay:l,isHandoff:m,onUpdate:f}=n;this.resolvedAt=te.now(),Ai(e,o,s,a)||((ue.instantAnimations||!l)&&(f==null||f(gt(e,n,r))),e[0]=e[e.length-1],Yt(n),n.repeat=0);let c=i?this.resolvedAt?this.resolvedAt-this.createdAt>Rs?this.resolvedAt:this.createdAt:this.createdAt:void 0,g=O(b({startTime:c,finalKeyframe:r},n),{keyframes:e}),d=!m&&Ei(g),R=(S=(C=g.motionValue)==null?void 0:C.owner)==null?void 0:S.current,A=d?new Er(O(b({},g),{element:R})):new We(g);A.finished.then(()=>{this.notifyFinished()}).catch(Te),this.pendingTimeline&&(this.stopTimeline=A.attachTimeline(this.pendingTimeline),this.pendingTimeline=void 0),this._animation=A}get finished(){return this._animation?this.animation.finished:this._finished}then(e,r){return this.finished.finally(e).then(()=>{})}get animation(){var e;return this._animation||((e=this.keyframeResolver)==null||e.resume(),pi()),this._animation}get duration(){return this.animation.duration}get iterationDuration(){return this.animation.iterationDuration}get time(){return this.animation.time}set time(e){this.animation.time=e}get speed(){return this.animation.speed}get state(){return this.animation.state}set speed(e){this.animation.speed=e}get startTime(){return this.animation.startTime}attachTimeline(e){return this._animation?this.stopTimeline=this.animation.attachTimeline(e):this.pendingTimeline=e,()=>this.stop()}play(){this.animation.play()}pause(){this.animation.pause()}complete(){this.animation.complete()}cancel(){var e;this._animation&&this.animation.cancel(),(e=this.keyframeResolver)==null||e.cancel()}};var Vr=class{constructor(e){this.stop=()=>this.runAll("stop"),this.animations=e.filter(Boolean)}get finished(){return Promise.all(this.animations.map(e=>e.finished))}getAll(e){return this.animations[0][e]}setAll(e,r){for(let n=0;n<this.animations.length;n++)this.animations[n][e]=r}attachTimeline(e){let r=this.animations.map(n=>n.attachTimeline(e));return()=>{r.forEach((n,i)=>{n&&n(),this.animations[i].stop()})}}get time(){return this.getAll("time")}set time(e){this.setAll("time",e)}get speed(){return this.getAll("speed")}set speed(e){this.setAll("speed",e)}get state(){return this.getAll("state")}get startTime(){return this.getAll("startTime")}get duration(){return wi(this.animations,"duration")}get iterationDuration(){return wi(this.animations,"iterationDuration")}runAll(e){this.animations.forEach(r=>r[e]())}play(){this.runAll("play")}pause(){this.runAll("pause")}cancel(){this.runAll("cancel")}complete(){this.runAll("complete")}};function wi(t,e){let r=0;for(let n=0;n<t.length;n++){let i=t[n][e];i!==null&&i>r&&(r=i)}return r}var qt=class extends Vr{then(e,r){return this.finished.finally(e).then(()=>{})}};var Ds=/^var\\(--(?:([\\w-]+)|([\\w-]+), ?([a-zA-Z\\d ()%#.,-]+))\\)/u;function Bs(t){let e=Ds.exec(t);if(!e)return[,];let[,r,n,i]=e;return[`--${r!=null?r:n}`,i]}var Os=4;function Tn(t,e,r=1){ge(r<=Os,`Max CSS variable fallback depth detected in property "${t}". This may indicate a circular fallback dependency.`,"max-css-var-depth");let[n,i]=Bs(t);if(!n)return;let o=window.getComputedStyle(e).getPropertyValue(n);if(o){let s=o.trim();return wt(s)?parseFloat(s):s}return mt(i)?Tn(i,e,r+1):i}var Fs={type:"spring",stiffness:500,damping:25,restSpeed:10},Ls=t=>({type:"spring",stiffness:550,damping:t===0?2*Math.sqrt(550):30,restSpeed:10}),ks={type:"keyframes",duration:.8},Ps={type:"keyframes",ease:[.25,.1,.35,1],duration:.3},Vi=(t,{keyframes:e})=>e.length>2?ks:Ae.has(t)?t.startsWith("scale")?Ls(e[1]):Fs:Ps;var Ns=t=>t!==null;function Mi(t,{repeat:e,repeatType:r="loop"},n){let i=t.filter(Ns),o=e&&r!=="loop"&&e%2===1?0:i.length-1;return!o||n===void 0?i[o]:n}function Mr(t,e){var r,n;return(n=(r=t==null?void 0:t[e])!=null?r:t==null?void 0:t.default)!=null?n:t}function _i(c){var g=c,{when:t,delay:e,delayChildren:r,staggerChildren:n,staggerDirection:i,repeat:o,repeatType:s,repeatDelay:a,from:l,elapsed:m}=g,f=X(g,["when","delay","delayChildren","staggerChildren","staggerDirection","repeat","repeatType","repeatDelay","from","elapsed"]);return!!Object.keys(f).length}var _r=(t,e,r,n={},i,o)=>s=>{let a=Mr(n,t)||{},l=a.delay||n.delay||0,{elapsed:m=0}=n;m=m-oe(l);let f=O(b({keyframes:Array.isArray(r)?r:[null,r],ease:"easeOut",velocity:e.getVelocity()},a),{delay:-m,onUpdate:g=>{e.set(g),a.onUpdate&&a.onUpdate(g)},onComplete:()=>{s(),a.onComplete&&a.onComplete()},name:t,motionValue:e,element:o?void 0:i});_i(a)||Object.assign(f,Vi(t,f)),f.duration&&(f.duration=oe(f.duration)),f.repeatDelay&&(f.repeatDelay=oe(f.repeatDelay)),f.from!==void 0&&(f.keyframes[0]=f.from);let c=!1;if((f.type===!1||f.duration===0&&!f.repeatDelay)&&(Yt(f),f.delay===0&&(c=!0)),(ue.instantAnimations||ue.skipAnimations)&&(c=!0,Yt(f),f.delay=0),f.allowFlatten=!a.type&&!a.ease,c&&!o&&e.get()!==void 0){let g=Mi(f.keyframes,a);if(g!==void 0){ce.update(()=>{f.onUpdate(g),f.onComplete()});return}}return a.isSync?new We(f):new wr(f)};function Ii(t){let e=[{},{}];return t==null||t.values.forEach((r,n)=>{e[0][n]=r.get(),e[1][n]=r.getVelocity()}),e}function Ir(t,e,r,n){if(typeof e=="function"){let[i,o]=Ii(n);e=e(r!==void 0?r:t.custom,i,o)}if(typeof e=="string"&&(e=t.variants&&t.variants[e]),typeof e=="function"){let[i,o]=Ii(n);e=e(r!==void 0?r:t.custom,i,o)}return e}function Ci(t,e,r){let n=t.getProps();return Ir(n,e,r!==void 0?r:n.custom,t)}var Cr=new Set(["width","height","top","left","right","bottom",...Me]);var Ri=30,Ks=t=>!isNaN(parseFloat(t)),Di={current:void 0},vn=class{constructor(e,r={}){this.canTrackVelocity=null,this.events={},this.updateAndNotify=n=>{var o;let i=te.now();if(this.updatedAt!==i&&this.setPrevFrameValue(),this.prev=this.current,this.setCurrent(n),this.current!==this.prev&&((o=this.events.change)==null||o.notify(this.current),this.dependents))for(let s of this.dependents)s.dirty()},this.hasAnimated=!1,this.setCurrent(e),this.owner=r.owner}setCurrent(e){this.current=e,this.updatedAt=te.now(),this.canTrackVelocity===null&&e!==void 0&&(this.canTrackVelocity=Ks(this.current))}setPrevFrameValue(e=this.current){this.prevFrameValue=e,this.prevUpdatedAt=this.updatedAt}onChange(e){return this.on("change",e)}on(e,r){this.events[e]||(this.events[e]=new Qe);let n=this.events[e].add(r);return e==="change"?()=>{n(),ce.read(()=>{this.events.change.getSize()||this.stop()})}:n}clearListeners(){for(let e in this.events)this.events[e].clear()}attach(e,r){this.passiveEffect=e,this.stopPassiveEffect=r}set(e){this.passiveEffect?this.passiveEffect(e,this.updateAndNotify):this.updateAndNotify(e)}setWithVelocity(e,r,n){this.set(r),this.prev=void 0,this.prevFrameValue=e,this.prevUpdatedAt=this.updatedAt-n}jump(e,r=!0){this.updateAndNotify(e),this.prev=e,this.prevUpdatedAt=this.prevFrameValue=void 0,r&&this.stop(),this.stopPassiveEffect&&this.stopPassiveEffect()}dirty(){var e;(e=this.events.change)==null||e.notify(this.current)}addDependent(e){this.dependents||(this.dependents=new Set),this.dependents.add(e)}removeDependent(e){this.dependents&&this.dependents.delete(e)}get(){return Di.current&&Di.current.push(this),this.current}getPrevious(){return this.prev}getVelocity(){let e=te.now();if(!this.canTrackVelocity||this.prevFrameValue===void 0||e-this.updatedAt>Ri)return 0;let r=Math.min(this.updatedAt-this.prevUpdatedAt,Ri);return Mt(parseFloat(this.current)-parseFloat(this.prevFrameValue),r)}start(e){return this.stop(),new Promise(r=>{this.hasAnimated=!0,this.animation=e(r),this.events.animationStart&&this.events.animationStart.notify()}).then(()=>{this.events.animationComplete&&this.events.animationComplete.notify(),this.clearAnimation()})}stop(){this.animation&&(this.animation.stop(),this.events.animationCancel&&this.events.animationCancel.notify()),this.clearAnimation()}isAnimating(){return!!this.animation}clearAnimation(){delete this.animation}destroy(){var e,r;(e=this.dependents)==null||e.clear(),(r=this.events.destroy)==null||r.notify(),this.clearListeners(),this.stop(),this.stopPassiveEffect&&this.stopPassiveEffect()}};function Be(t,e){return new vn(t,e)}var Bi=t=>Array.isArray(t);function Us(t,e,r){t.hasValue(e)?t.getValue(e).set(r):t.addValue(e,Be(r))}function Gs(t){return Bi(t)?t[t.length-1]||0:t}function Oi(t,e){let s=Ci(t,e)||{},{transitionEnd:n={},transition:i={}}=s,o=X(s,["transitionEnd","transition"]);o=b(b({},o),n);for(let a in o){let l=Gs(o[a]);Us(t,a,l)}}var J=t=>!!(t&&t.getVelocity);function Fi(t){return!!(J(t)&&t.add)}function Li(t,e){let r=t.getValue("willChange");if(Fi(r))return r.add(e);if(!r&&ue.WillChange){let n=new ue.WillChange("auto");t.addValue("willChange",n),n.add(e)}}function xt(t){return t.replace(/([A-Z])/g,e=>`-${e.toLowerCase()}`)}var $s="framerAppearId",ki="data-"+xt($s);function Pi(t){return t.props[ki]}function Ws({protectedKeys:t,needsAnimating:e},r){let n=t.hasOwnProperty(r)&&e[r]!==!0;return e[r]=!1,n}function bn(t,e,{delay:r=0,transitionOverride:n,type:i}={}){var c;let f=e,{transition:o=t.getDefaultTransition(),transitionEnd:s}=f,a=X(f,["transition","transitionEnd"]);n&&(o=n);let l=[],m=i&&t.animationState&&t.animationState.getState()[i];for(let g in a){let d=t.getValue(g,(c=t.latestValues[g])!=null?c:null),R=a[g];if(R===void 0||m&&Ws(m,g))continue;let A=b({delay:r},Mr(o||{},g)),C=d.get();if(C!==void 0&&!d.isAnimating&&!Array.isArray(R)&&R===C&&!A.velocity)continue;let S=!1;if(window.MotionHandoffAnimation){let D=Pi(t);if(D){let F=window.MotionHandoffAnimation(D,g,ce);F!==null&&(A.startTime=F,S=!0)}}Li(t,g),d.start(_r(g,d,R,t.shouldReduceMotion&&Cr.has(g)?{type:!1}:A,t,S));let I=d.animation;I&&l.push(I)}return s&&Promise.all(l).then(()=>{ce.update(()=>{s&&Oi(t,s)})}),l}var Ni={test:t=>t==="auto",parse:t=>t};var Rr=t=>e=>e.test(t);var Sn=[Ee,y,Ue,Ve,$n,Gn,Ni],An=t=>Sn.find(Rr(t));function Ki(t){return typeof t=="number"?t===0:t!==null?t==="none"||t==="0"||Vt(t):!0}var Ys=new Set(["brightness","contrast","saturate","opacity"]);function qs(t){let[e,r]=t.slice(0,-1).split("(");if(e==="drop-shadow")return t;let[n]=r.match(ct)||[];if(!n)return t;let i=r.replace(n,""),o=Ys.has(e)?1:0;return n!==r&&(o*=100),e+"("+o+i+")"}var Hs=/\\b([a-z-]*)\\(.*?\\)/gu,Ht=O(b({},pe),{getAnimatableNone:t=>{let e=t.match(Hs);return e?e.map(qs).join(" "):t}});var En=O(b({},Ee),{transform:Math.round});var Ui={rotate:Ve,rotateX:Ve,rotateY:Ve,rotateZ:Ve,scale:Pt,scaleX:Pt,scaleY:Pt,scaleZ:Pt,skew:Ve,skewX:Ve,skewY:Ve,distance:y,translateX:y,translateY:y,translateZ:y,x:y,y,z:y,perspective:y,transformPerspective:y,opacity:Ce,originX:rn,originY:rn,originZ:y};var yt=O(b({borderWidth:y,borderTopWidth:y,borderRightWidth:y,borderBottomWidth:y,borderLeftWidth:y,borderRadius:y,borderTopLeftRadius:y,borderTopRightRadius:y,borderBottomRightRadius:y,borderBottomLeftRadius:y,width:y,maxWidth:y,height:y,maxHeight:y,top:y,right:y,bottom:y,left:y,inset:y,insetBlock:y,insetBlockStart:y,insetBlockEnd:y,insetInline:y,insetInlineStart:y,insetInlineEnd:y,padding:y,paddingTop:y,paddingRight:y,paddingBottom:y,paddingLeft:y,paddingBlock:y,paddingBlockStart:y,paddingBlockEnd:y,paddingInline:y,paddingInlineStart:y,paddingInlineEnd:y,margin:y,marginTop:y,marginRight:y,marginBottom:y,marginLeft:y,marginBlock:y,marginBlockStart:y,marginBlockEnd:y,marginInline:y,marginInlineStart:y,marginInlineEnd:y,fontSize:y,backgroundPositionX:y,backgroundPositionY:y},Ui),{zIndex:En,fillOpacity:Ce,strokeOpacity:Ce,numOctaves:En});var zs=O(b({},yt),{color:Q,backgroundColor:Q,outlineColor:Q,fill:Q,stroke:Q,borderColor:Q,borderTopColor:Q,borderRightColor:Q,borderBottomColor:Q,borderLeftColor:Q,filter:Ht,WebkitFilter:Ht}),Dr=t=>zs[t];function Br(t,e){let r=Dr(t);return r!==Ht&&(r=pe),r.getAnimatableNone?r.getAnimatableNone(e):void 0}var js=new Set(["auto","none","0"]);function Gi(t,e,r){let n=0,i;for(;n<t.length&&!i;){let o=t[n];typeof o=="string"&&!js.has(o)&&et(o).values.length&&(i=t[n]),n++}if(i&&r)for(let o of e)t[o]=Br(r,i)}var Or=class extends Ye{constructor(e,r,n,i,o){super(e,r,n,i,o,!0)}readKeyframes(){let{unresolvedKeyframes:e,element:r,name:n}=this;if(!r||!r.current)return;super.readKeyframes();for(let f=0;f<e.length;f++){let c=e[f];if(typeof c=="string"&&(c=c.trim(),mt(c))){let g=Tn(c,r.current);g!==void 0&&(e[f]=g),f===e.length-1&&(this.finalKeyframe=c)}}if(this.resolveNoneKeyframes(),!Cr.has(n)||e.length!==2)return;let[i,o]=e,s=An(i),a=An(o),l=en(i),m=en(o);if(l!==m&&De[n]){this.needsMeasurement=!0;return}if(s!==a)if(mn(s)&&mn(a))for(let f=0;f<e.length;f++){let c=e[f];typeof c=="string"&&(e[f]=parseFloat(c))}else De[n]&&(this.needsMeasurement=!0)}resolveNoneKeyframes(){let{unresolvedKeyframes:e,name:r}=this,n=[];for(let i=0;i<e.length;i++)(e[i]===null||Ki(e[i]))&&n.push(i);n.length&&Gi(e,n,r)}measureInitialState(){let{element:e,unresolvedKeyframes:r,name:n}=this;if(!e||!e.current)return;n==="height"&&(this.suspendedScrollY=window.pageYOffset),this.measuredOrigin=De[n](e.measureViewportBox(),window.getComputedStyle(e.current)),r[0]=this.measuredOrigin;let i=r[r.length-1];i!==void 0&&e.getValue(n,i).jump(i,!1)}measureEndState(){var a;let{element:e,name:r,unresolvedKeyframes:n}=this;if(!e||!e.current)return;let i=e.getValue(r);i&&i.jump(this.measuredOrigin,!1);let o=n.length-1,s=n[o];n[o]=De[r](e.measureViewportBox(),window.getComputedStyle(e.current)),s!==null&&this.finalKeyframe===void 0&&(this.finalKeyframe=s),(a=this.removedTransforms)!=null&&a.length&&this.removedTransforms.forEach(([l,m])=>{e.getValue(l).set(m)}),this.resolveNoneKeyframes()}};function wn(t,e,r){var n;if(t==null)return[];if(t instanceof EventTarget)return[t];if(typeof t=="string"){let i=document;e&&(i=e.current);let o=(n=r==null?void 0:r[t])!=null?n:i.querySelectorAll(t);return o?Array.from(o):[]}return Array.from(t).filter(i=>i!=null)}var Fr=(t,e)=>e&&typeof t=="number"?e.transform(t):t;var{schedule:$i,cancel:yh}=fr(queueMicrotask,!1);function zt(t){return Xr(t)&&"ownerSVGElement"in t}function Vn(t){return zt(t)&&t.tagName==="svg"}function Wi(t,e){if(t==="first")return 0;{let r=e-1;return t==="last"?r:r/2}}function Lr(t=.1,{startDelay:e=0,from:r=0,ease:n}={}){return(i,o)=>{let s=typeof r=="number"?r:Wi(r,o),a=Math.abs(s-i),l=t*a;if(n){let m=o*t;l=at(n)(l/m)*m}return e+l}}var Xs=[...Sn,Q,pe],Yi=t=>Xs.find(Rr(t));var qi=()=>({min:0,max:0}),Tt=()=>({x:qi(),y:qi()});var jt={current:null},kr={current:!1};var Zs=typeof window!="undefined";function Hi(){if(kr.current=!0,!!Zs)if(window.matchMedia){let t=window.matchMedia("(prefers-reduced-motion)"),e=()=>jt.current=t.matches;t.addEventListener("change",e),e()}else jt.current=!1}var Oe=new WeakMap;function zi(t){return t!==null&&typeof t=="object"&&typeof t.start=="function"}function ji(t){return typeof t=="string"||Array.isArray(t)}var Js=["animate","whileInView","whileFocus","whileHover","whileTap","whileDrag","exit"],Xi=["initial",...Js];function Mn(t){return zi(t.animate)||Xi.some(e=>ji(t[e]))}function Zi(t){return!!(Mn(t)||t.variants)}function Ji(t,e,r){for(let n in e){let i=e[n],o=r[n];if(J(i))t.addValue(n,i);else if(J(o))t.addValue(n,Be(i,{owner:t}));else if(o!==i)if(t.hasValue(n)){let s=t.getValue(n);s.liveStyle===!0?s.jump(i):s.hasAnimated||s.set(i)}else{let s=t.getStaticValue(n);t.addValue(n,Be(s!==void 0?s:i,{owner:t}))}}for(let n in r)e[n]===void 0&&t.removeValue(n);return e}var Qi=["AnimationStart","AnimationComplete","Update","BeforeLayoutMeasure","LayoutMeasure","LayoutAnimationStart","LayoutAnimationComplete"],eo={};var vt=class{scrapeMotionValuesFromProps(e,r,n){return{}}constructor({parent:e,props:r,presenceContext:n,reducedMotionConfig:i,blockInitialAnimation:o,visualState:s},a={}){this.current=null,this.children=new Set,this.isVariantNode=!1,this.isControllingVariants=!1,this.shouldReduceMotion=null,this.values=new Map,this.KeyframeResolver=Ye,this.features={},this.valueSubscriptions=new Map,this.prevMotionValues={},this.events={},this.propEventSubscriptions={},this.notifyUpdate=()=>this.notify("Update",this.latestValues),this.render=()=>{this.current&&(this.triggerBuild(),this.renderInstance(this.current,this.renderState,this.props.style,this.projection))},this.renderScheduledAt=0,this.scheduleRender=()=>{let d=te.now();this.renderScheduledAt<d&&(this.renderScheduledAt=d,ce.render(this.render,!1,!0))};let{latestValues:l,renderState:m}=s;this.latestValues=l,this.baseTarget=b({},l),this.initialValues=r.initial?b({},l):{},this.renderState=m,this.parent=e,this.props=r,this.presenceContext=n,this.depth=e?e.depth+1:0,this.reducedMotionConfig=i,this.options=a,this.blockInitialAnimation=!!o,this.isControllingVariants=Mn(r),this.isVariantNode=Zi(r),this.isVariantNode&&(this.variantChildren=new Set),this.manuallyAnimateOnMount=!!(e&&e.current);let g=this.scrapeMotionValuesFromProps(r,{},this),{willChange:f}=g,c=X(g,["willChange"]);for(let d in c){let R=c[d];l[d]!==void 0&&J(R)&&R.set(l[d])}}mount(e){var r;this.current=e,Oe.set(e,this),this.projection&&!this.projection.instance&&this.projection.mount(e),this.parent&&this.isVariantNode&&!this.isControllingVariants&&(this.removeFromVariantTree=this.parent.addVariantChild(this)),this.values.forEach((n,i)=>this.bindToMotionValue(i,n)),this.reducedMotionConfig==="never"?this.shouldReduceMotion=!1:this.reducedMotionConfig==="always"?this.shouldReduceMotion=!0:(kr.current||Hi(),this.shouldReduceMotion=jt.current),(r=this.parent)==null||r.addChild(this),this.update(this.props,this.presenceContext)}unmount(){var e;this.projection&&this.projection.unmount(),kt(this.notifyUpdate),kt(this.render),this.valueSubscriptions.forEach(r=>r()),this.valueSubscriptions.clear(),this.removeFromVariantTree&&this.removeFromVariantTree(),(e=this.parent)==null||e.removeChild(this);for(let r in this.events)this.events[r].clear();for(let r in this.features){let n=this.features[r];n&&(n.unmount(),n.isMounted=!1)}this.current=null}addChild(e){var r;this.children.add(e),(r=this.enteringChildren)!=null||(this.enteringChildren=new Set),this.enteringChildren.add(e)}removeChild(e){this.children.delete(e),this.enteringChildren&&this.enteringChildren.delete(e)}bindToMotionValue(e,r){this.valueSubscriptions.has(e)&&this.valueSubscriptions.get(e)();let n=Ae.has(e);n&&this.onBindTransform&&this.onBindTransform();let i=r.on("change",s=>{this.latestValues[e]=s,this.props.onUpdate&&ce.preRender(this.notifyUpdate),n&&this.projection&&(this.projection.isTransformDirty=!0),this.scheduleRender()}),o;typeof window!="undefined"&&window.MotionCheckAppearSync&&(o=window.MotionCheckAppearSync(this,e,r)),this.valueSubscriptions.set(e,()=>{i(),o&&o(),r.owner&&r.stop()})}sortNodePosition(e){return!this.current||!this.sortInstanceNodePosition||this.type!==e.type?0:this.sortInstanceNodePosition(this.current,e.current)}updateFeatures(){let e="animation";for(e in eo){let r=eo[e];if(!r)continue;let{isEnabled:n,Feature:i}=r;if(!this.features[e]&&i&&n(this.props)&&(this.features[e]=new i(this)),this.features[e]){let o=this.features[e];o.isMounted?o.update():(o.mount(),o.isMounted=!0)}}}triggerBuild(){this.build(this.renderState,this.latestValues,this.props)}measureViewportBox(){return this.current?this.measureInstanceViewportBox(this.current,this.props):Tt()}getStaticValue(e){return this.latestValues[e]}setStaticValue(e,r){this.latestValues[e]=r}update(e,r){(e.transformTemplate||this.props.transformTemplate)&&this.scheduleRender(),this.prevProps=this.props,this.props=e,this.prevPresenceContext=this.presenceContext,this.presenceContext=r;for(let n=0;n<Qi.length;n++){let i=Qi[n];this.propEventSubscriptions[i]&&(this.propEventSubscriptions[i](),delete this.propEventSubscriptions[i]);let o="on"+i,s=e[o];s&&(this.propEventSubscriptions[i]=this.on(i,s))}this.prevMotionValues=Ji(this,this.scrapeMotionValuesFromProps(e,this.prevProps||{},this),this.prevMotionValues),this.handleChildMotionValue&&this.handleChildMotionValue()}getProps(){return this.props}getVariant(e){return this.props.variants?this.props.variants[e]:void 0}getDefaultTransition(){return this.props.transition}getTransformPagePoint(){return this.props.transformPagePoint}getClosestVariantNode(){return this.isVariantNode?this:this.parent?this.parent.getClosestVariantNode():void 0}addVariantChild(e){let r=this.getClosestVariantNode();if(r)return r.variantChildren&&r.variantChildren.add(e),()=>r.variantChildren.delete(e)}addValue(e,r){let n=this.values.get(e);r!==n&&(n&&this.removeValue(e),this.bindToMotionValue(e,r),this.values.set(e,r),this.latestValues[e]=r.get())}removeValue(e){this.values.delete(e);let r=this.valueSubscriptions.get(e);r&&(r(),this.valueSubscriptions.delete(e)),delete this.latestValues[e],this.removeValueFromRenderState(e,this.renderState)}hasValue(e){return this.values.has(e)}getValue(e,r){if(this.props.values&&this.props.values[e])return this.props.values[e];let n=this.values.get(e);return n===void 0&&r!==void 0&&(n=Be(r===null?void 0:r,{owner:this}),this.addValue(e,n)),n}readValue(e,r){var i;let n=this.latestValues[e]!==void 0||!this.current?this.latestValues[e]:(i=this.getBaseTargetFromProps(this.props,e))!=null?i:this.readValueFromInstance(this.current,e,this.options);return n!=null&&(typeof n=="string"&&(wt(n)||Vt(n))?n=parseFloat(n):!Yi(n)&&pe.test(r)&&(n=Br(e,r)),this.setBaseTarget(e,J(n)?n.get():n)),J(n)?n.get():n}setBaseTarget(e,r){this.baseTarget[e]=r}getBaseTarget(e){var o;let{initial:r}=this.props,n;if(typeof r=="string"||typeof r=="object"){let s=Ir(this.props,r,(o=this.presenceContext)==null?void 0:o.custom);s&&(n=s[e])}if(r&&n!==void 0)return n;let i=this.getBaseTargetFromProps(this.props,e);return i!==void 0&&!J(i)?i:this.initialValues[e]!==void 0&&n===void 0?void 0:this.baseTarget[e]}on(e,r){return this.events[e]||(this.events[e]=new Qe),this.events[e].add(r)}notify(e,...r){this.events[e]&&this.events[e].notify(...r)}scheduleRenderMicrotask(){$i.render(this.render)}};var bt=class extends vt{constructor(){super(...arguments),this.KeyframeResolver=Or}sortInstanceNodePosition(e,r){return e.compareDocumentPosition(r)&2?1:-1}getBaseTargetFromProps(e,r){let n=e.style;return n?n[r]:void 0}removeValueFromRenderState(e,{vars:r,style:n}){delete r[e],delete n[e]}handleChildMotionValue(){this.childSubscription&&(this.childSubscription(),delete this.childSubscription);let{children:e}=this.props;J(e)&&(this.childSubscription=e.on("change",r=>{this.current&&(this.current.textContent=`${r}`)}))}};function to({top:t,left:e,right:r,bottom:n}){return{x:{min:e,max:r},y:{min:t,max:n}}}function ro(t,e){if(!e)return t;let r=e({x:t.left,y:t.top}),n=e({x:t.right,y:t.bottom});return{top:r.y,left:r.x,bottom:n.y,right:n.x}}function no(t,e){return to(ro(t.getBoundingClientRect(),e))}var Qs={x:"translateX",y:"translateY",z:"translateZ",transformPerspective:"perspective"},ea=Me.length;function io(t,e,r){let n="",i=!0;for(let o=0;o<ea;o++){let s=Me[o],a=t[s];if(a===void 0)continue;let l=!0;if(typeof a=="number")l=a===(s.startsWith("scale")?1:0);else{let m=parseFloat(a);l=s.startsWith("scale")?m===1:m===0}if(!l||r){let m=Fr(a,yt[s]);if(!l){i=!1;let f=Qs[s]||s;n+=`${f}(${m}) `}r&&(e[s]=m)}}return n=n.trim(),r?n=r(e,i?"":n):i&&(n="none"),n}function Pr(t,e,r){let{style:n,vars:i,transformOrigin:o}=t,s=!1,a=!1;for(let l in e){let m=e[l];if(Ae.has(l)){s=!0;continue}else if(mr(l)){i[l]=m;continue}else{let f=Fr(m,yt[l]);l.startsWith("origin")?(a=!0,o[l]=f):n[l]=f}}if(e.transform||(s||r?n.transform=io(e,t.transform,r):n.transform&&(n.transform="none")),a){let{originX:l="50%",originY:m="50%",originZ:f=0}=o;n.transformOrigin=`${l} ${m} ${f}`}}function Nr(t,{style:e,vars:r},n,i){let o=t.style,s;for(s in e)o[s]=e[s];i==null||i.applyProjectionStyles(o,n);for(s in r)o.setProperty(s,r[s])}function oo(t,e){return e.max===e.min?0:t/(e.max-e.min)*100}var St={correct:(t,e)=>{if(!e.target)return t;if(typeof t=="string")if(y.test(t))t=parseFloat(t);else return t;let r=oo(t,e.target.x),n=oo(t,e.target.y);return`${r}% ${n}%`}};var so={correct:(t,{treeScale:e,projectionDelta:r})=>{let n=t,i=pe.parse(t);if(i.length>5)return n;let o=pe.createTransformer(t),s=typeof i[0]!="number"?1:0,a=r.x.scale*e.x,l=r.y.scale*e.y;i[0+s]/=a,i[1+s]/=l;let m=ve(a,l,.5);return typeof i[2+s]=="number"&&(i[2+s]/=m),typeof i[3+s]=="number"&&(i[3+s]/=m),o(i)}};var ao={borderRadius:O(b({},St),{applyTo:["borderTopLeftRadius","borderTopRightRadius","borderBottomLeftRadius","borderBottomRightRadius"]}),borderTopLeftRadius:St,borderTopRightRadius:St,borderBottomLeftRadius:St,borderBottomRightRadius:St,boxShadow:so};function lo(t,{layout:e,layoutId:r}){return Ae.has(t)||t.startsWith("origin")||(e||r!==void 0)&&(!!ao[t]||t==="opacity")}function Kr(t,e,r){var s;let n=t.style,i=e==null?void 0:e.style,o={};if(!n)return o;for(let a in n)(J(n[a])||i&&J(i[a])||lo(a,t)||((s=r==null?void 0:r.getValue(a))==null?void 0:s.liveStyle)!==void 0)&&(o[a]=n[a]);return o}function ta(t){return window.getComputedStyle(t)}var Xt=class extends bt{constructor(){super(...arguments),this.type="html",this.renderInstance=Nr}readValueFromInstance(e,r){var n;if(Ae.has(r))return(n=this.projection)!=null&&n.isProjecting?vr(r):fi(e,r);{let i=ta(e),o=(mr(r)?i.getPropertyValue(r):i[r])||0;return typeof o=="string"?o.trim():o}}measureInstanceViewportBox(e,{transformPagePoint:r}){return no(e,r)}build(e,r,n){Pr(e,r,n.transformTemplate)}scrapeMotionValuesFromProps(e,r,n){return Kr(e,r,n)}};function ra(t,e){return t in e}var Zt=class extends vt{constructor(){super(...arguments),this.type="object"}readValueFromInstance(e,r){if(ra(r,e)){let n=e[r];if(typeof n=="string"||typeof n=="number")return n}}getBaseTargetFromProps(){}removeValueFromRenderState(e,r){delete r.output[e]}measureInstanceViewportBox(){return Tt()}build(e,r){Object.assign(e.output,r)}renderInstance(e,{output:r}){Object.assign(e,r)}sortInstanceNodePosition(){return 0}};var na={offset:"stroke-dashoffset",array:"stroke-dasharray"},ia={offset:"strokeDashoffset",array:"strokeDasharray"};function fo(t,e,r=1,n=0,i=!0){t.pathLength=1;let o=i?na:ia;t[o.offset]=`${-n}`,t[o.array]=`${e} ${r}`}var oa=["offsetDistance","offsetPath","offsetRotate","offsetAnchor"];function uo(t,c,l,m,f){var g=c,{attrX:e,attrY:r,attrScale:n,pathLength:i,pathSpacing:o=1,pathOffset:s=0}=g,a=X(g,["attrX","attrY","attrScale","pathLength","pathSpacing","pathOffset"]);var A,C;if(Pr(t,a,m),l){t.style.viewBox&&(t.attrs.viewBox=t.style.viewBox);return}t.attrs=t.style,t.style={};let{attrs:d,style:R}=t;d.transform&&(R.transform=d.transform,delete d.transform),(R.transform||d.transformOrigin)&&(R.transformOrigin=(A=d.transformOrigin)!=null?A:"50% 50%",delete d.transformOrigin),R.transform&&(R.transformBox=(C=f==null?void 0:f.transformBox)!=null?C:"fill-box",delete d.transformBox);for(let S of oa)d[S]!==void 0&&(R[S]=d[S],delete d[S]);e!==void 0&&(d.x=e),r!==void 0&&(d.y=r),n!==void 0&&(d.scale=n),i!==void 0&&fo(d,i,o,s,!1)}var Ur=new Set(["baseFrequency","diffuseConstant","kernelMatrix","kernelUnitLength","keySplines","keyTimes","limitingConeAngle","markerHeight","markerWidth","numOctaves","targetX","targetY","surfaceScale","specularConstant","specularExponent","stdDeviation","tableValues","viewBox","gradientTransform","pathLength","startOffset","textLength","lengthAdjust"]);var mo=t=>typeof t=="string"&&t.toLowerCase()==="svg";function co(t,e,r,n){Nr(t,e,void 0,n);for(let i in e.attrs)t.setAttribute(Ur.has(i)?i:xt(i),e.attrs[i])}function po(t,e,r){let n=Kr(t,e,r);for(let i in t)if(J(t[i])||J(e[i])){let o=Me.indexOf(i)!==-1?"attr"+i.charAt(0).toUpperCase()+i.substring(1):i;n[o]=t[i]}return n}var Jt=class extends bt{constructor(){super(...arguments),this.type="svg",this.isSVGTag=!1,this.measureInstanceViewportBox=Tt}getBaseTargetFromProps(e,r){return e[r]}readValueFromInstance(e,r){if(Ae.has(r)){let n=Dr(r);return n&&n.default||0}return r=Ur.has(r)?r:xt(r),e.getAttribute(r)}scrapeMotionValuesFromProps(e,r,n){return po(e,r,n)}build(e,r,n){uo(e,r,this.isSVGTag,n.transformTemplate,n.style)}renderInstance(e,r,n,i){co(e,r,n,i)}mount(e){this.isSVGTag=mo(e.tagName),super.mount(e)}};function _n(t,e,r){let n=J(t)?t:Be(t);return n.start(_r("",n,e,r)),n.animation}function Qt(t){return typeof t=="object"&&!Array.isArray(t)}function Gr(t,e,r,n){return t==null?[]:typeof t=="string"&&Qt(e)?wn(t,r,n):t instanceof NodeList?Array.from(t):Array.isArray(t)?t.filter(i=>i!=null):[t]}function ho(t,e,r){return t*(e+1)}function In(t,e,r,n){var i;return typeof e=="number"?e:e.startsWith("-")||e.startsWith("+")?Math.max(0,t+parseFloat(e)):e==="<"?r:e.startsWith("<")?Math.max(0,r+parseFloat(e.slice(1))):(i=n.get(e))!=null?i:t}function sa(t,e,r){for(let n=0;n<t.length;n++){let i=t[n];i.at>e&&i.at<r&&(je(t,i),n--)}}function go(t,e,r,n,i,o){sa(t,i,o);for(let s=0;s<e.length;s++)t.push({value:e[s],at:ve(i,o,n[s]),easing:Ot(r,s)})}function xo(t,e){for(let r=0;r<t.length;r++)t[r]=t[r]/(e+1)}function yo(t,e){return t.at===e.at?t.value===null?1:e.value===null?-1:0:t.at-e.at}var aa="easeInOut",la=20;function bo(t,o={},n,i){var s=o,{defaultTransition:e={}}=s,r=X(s,["defaultTransition"]);let a=e.duration||.3,l=new Map,m=new Map,f={},c=new Map,g=0,d=0,R=0;for(let A=0;A<t.length;A++){let C=t[A];if(typeof C=="string"){c.set(C,d);continue}else if(!Array.isArray(C)){c.set(C.name,In(d,C.at,g,c));continue}let[S,I,D={}]=C;D.at!==void 0&&(d=In(d,D.at,g,c));let F=0,M=(B,K,v,P=0,N=0)=>{let k=fa(B),V=K,{delay:be=0,times:re=Wt(k),type:Le=e.type||"keyframes",repeat:xe,repeatType:rr,repeatDelay:de=0}=V,Et=X(V,["delay","times","type","repeat","repeatType","repeatDelay"]),{ease:H=e.ease||"easeOut",duration:ne}=K,nr=typeof be=="function"?be(P,N):be,He=k.length,p=ot(Le)?Le:i==null?void 0:i[Le||"keyframes"];if(He<=2&&p){let T=100;if(He===2&&ca(k)){let E=k[1]-k[0];T=Math.abs(E)}let x=b(b({},e),Et);ne!==void 0&&(x.duration=oe(ne));let _=Ut(x,T,p);H=_.ease,ne=_.duration}ne!=null||(ne=a);let u=d+nr;re.length===1&&re[0]===0&&(re[1]=1);let h=re.length-k.length;if(h>0&&$t(re,h),k.length===1&&k.unshift(null),xe){ge(xe<la,"Repeat count too high, must be less than 20","repeat-count-high"),ne=ho(ne,xe);let T=[...k],x=[...re];H=Array.isArray(H)?[...H]:[H];let _=[...H];for(let E=0;E<xe;E++){k.push(...T);for(let L=0;L<T.length;L++)re.push(x[L]+(E+1)),H.push(L===0?"linear":Ot(_,L-1))}xo(re,xe)}let w=u+ne;go(v,k,H,re,u,w),F=Math.max(nr+ne,F),R=Math.max(w,R)};if(J(S)){let B=To(S,m);M(I,D,vo("default",B))}else{let B=Gr(S,I,n,f),K=B.length;for(let v=0;v<K;v++){I=I,D=D;let P=B[v],N=To(P,m);for(let k in I)M(I[k],ua(D,k),vo(k,N),v,K)}}g=d,d+=F}return m.forEach((A,C)=>{for(let I in A){let D=A[I];D.sort(yo);let F=[],M=[],B=[];for(let N=0;N<D.length;N++){let{at:k,value:be,easing:re}=D[N];F.push(be),M.push(Je(0,R,k)),B.push(re||"easeOut")}M[0]!==0&&(M.unshift(0),F.unshift(F[0]),B.unshift(aa)),M[M.length-1]!==1&&(M.push(1),F.push(null)),l.has(C)||l.set(C,{keyframes:{},transition:{}});let K=l.get(C);K.keyframes[I]=F;let S=e,{type:v}=S,P=X(S,["type"]);K.transition[I]=b(O(b({},P),{duration:R,ease:B,times:M}),r)}}),l}function To(t,e){return!e.has(t)&&e.set(t,{}),e.get(t)}function vo(t,e){return e[t]||(e[t]=[]),e[t]}function fa(t){return Array.isArray(t)?t:[t]}function ua(t,e){return t&&t[e]?b(b({},t),t[e]):b({},t)}var ma=t=>typeof t=="number",ca=t=>t.every(ma);function So(t){let e={presenceContext:null,props:{},visualState:{renderState:{transform:{},transformOrigin:{},style:{},vars:{},attrs:{}},latestValues:{}}},r=zt(t)&&!Vn(t)?new Jt(e):new Xt(e);r.mount(t),Oe.set(t,r)}function Ao(t){let e={presenceContext:null,props:{},visualState:{renderState:{output:{}},latestValues:{}}},r=new Zt(e);r.mount(t),Oe.set(t,r)}function pa(t,e){return J(t)||typeof t=="number"||typeof t=="string"&&!Qt(e)}function $r(t,e,r,n){let i=[];if(pa(t,e))i.push(_n(t,Qt(e)&&e.default||e,r&&(r.default||r)));else{if(t==null)return i;let o=Gr(t,e,n),s=o.length;ge(!!s,"No valid elements provided.","no-valid-elements");for(let a=0;a<s;a++){let l=o[a],m=l instanceof Element?So:Ao;Oe.has(l)||m(l);let f=Oe.get(l),c=b({},r);"delay"in c&&typeof c.delay=="function"&&(c.delay=c.delay(a,s)),i.push(...bn(f,O(b({},e),{transition:c}),{}))}}return i}function Eo(t,e,r){let n=[];return bo(t,e,r,{spring:Re}).forEach(({keyframes:o,transition:s},a)=>{n.push(...$r(a,o,s))}),n}function da(t){return Array.isArray(t)&&t.some(Array.isArray)}function wo(t){function e(r,n,i){let o=[],s;if(da(r))o=Eo(r,n,t);else{let l=i||{},{onComplete:m}=l,f=X(l,["onComplete"]);typeof m=="function"&&(s=m),o=$r(r,n,f,t)}let a=new qt(o);return s&&a.finished.then(s),t&&(t.animations.push(a),a.finished.then(()=>{je(t.animations,a)})),a}return e}var Cn=wo();var ha=Object.defineProperty;var ga=(t,e)=>{for(var r in e)ha(t,r,{get:e[r],enumerable:!0})};var qe=({initialStyles:t,keyframes:e})=>{let r=Cn,n=o=>Object.fromEntries(Object.entries(o).map(([s,a])=>[s,Array.isArray(a)?[...a].reverse():a])),i=(o,s={})=>{let{target:a,insertAfter:l,display:m=""}=s;Array.isArray(o)||(o=[o]);for(let f of o)f.style.display=m,Object.assign(f.style,t),a&&l!==void 0?l?a.insertBefore(f,l.nextSibling):a.prepend(f):a&&a.appendChild(f)};return{prepareIn:i,animateIn:async(o,s={})=>{let A=s,{prepared:a,stagger:l,display:m,duration:f}=A,c=X(A,["prepared","stagger","display","duration"]),g=f?f/1e3:void 0;a||i(o,s);let d=Array.isArray(o)?o:[o],{finished:R}=r(d,e,O(b({},c),{delay:l?Lr(l/1e3):void 0,duration:g}));return await R},animateOut:async(o,s={})=>{let S=s,{remove:a,stagger:l,target:m,insertAfter:f,display:c="none",duration:g}=S,d=X(S,["remove","stagger","target","insertAfter","display","duration"]),R=g?g/1e3:void 0,A=(Array.isArray(o)?o:[o]).filter(I=>document.body.contains(I));if(!A.length)return;let{finished:C}=r(A,n(e),O(b({},d),{duration:R,delay:l?Lr(l/1e3):void 0}));await C;for(let I of A)m&&f!==void 0?f?m.insertBefore(I,f.nextSibling):m.prepend(I):m&&m.appendChild(I),a?I.remove():I.style.display=c}}};var Wy={fade:qe({keyframes:{opacity:[0,1]},initialStyles:{opacity:"0"}}),"slide-up":qe({keyframes:{y:[100,0],opacity:[0,1]},initialStyles:{transform:"translateY(100px)",opacity:"0"}}),"slide-down":qe({keyframes:{y:[-100,0],opacity:[0,1]},initialStyles:{transform:"translateY(-100px)",opacity:"0"}}),"slide-right":qe({keyframes:{x:[-100,0],opacity:[0,1]},initialStyles:{transform:"translateX(-100px)",opacity:"0"}}),"slide-left":qe({keyframes:{x:[100,0],opacity:[0,1]},initialStyles:{transform:"translateX(100px)",opacity:"0"}}),grow:qe({keyframes:{scale:[0,1],opacity:[0,1]},initialStyles:{transform:"scale(0)",opacity:"0"}}),shrink:qe({keyframes:{scale:[1.25,1],opacity:[0,1]},initialStyles:{transform:"scale(1.25)",opacity:"0"}}),spin:qe({keyframes:{rotate:[900,0],opacity:[0,1]},initialStyles:{transform:"rotate(900deg)",opacity:"0"}})};var er=t=>typeof t=="string",xa=t=>typeof t=="number";var Rn=t=>t===void 0,Fe=t=>t instanceof Date;var At=t=>{if(Fe(t))return t;if(t==="")return;let e=new Date(t);if(!isNaN(e.getTime()))return e};var ya={};ga(ya,{ACCORDION_ATTRIBUTE:()=>Ta,AUTO_VIDEO_ATTRIBUTE:()=>va,CODE_HIGHLIGHT_ATTRIBUTE:()=>ba,COMBO_BOX_ATTRIBUTE:()=>Sa,COPY_CLIP_ATTRIBUTE:()=>Ea,DISPLAY_VALUES_ATTRIBUTE:()=>wa,DOCS_ATTRIBUTE:()=>Va,FAV_CUSTOM_ATTRIBUTE:()=>Ma,FORM_SUBMIT_ATTRIBUTE:()=>_a,INJECT_ATTRIBUTE:()=>Aa,INPUT_ACTIVE_ATTRIBUTE:()=>Ia,INPUT_COUNTER_ATTRIBUTE:()=>Ca,LIST_ATTRIBUTE:()=>Fa,MIRROR_CLICK_ATTRIBUTE:()=>Ra,MIRROR_INPUT_ATTRIBUTE:()=>Da,MODAL_ATTRIBUTE:()=>Ba,NUMBER_COUNT_ATTRIBUTE:()=>Oa,QUERY_PARAM_ATTRIBUTE:()=>La,RANGE_SLIDER_ATTRIBUTE:()=>ka,READ_TIME_ATTRIBUTE:()=>Ya,REMOVE_QUERY_ATTRIBUTE:()=>qa,SCROLL_DISABLE_ATTRIBUTE:()=>Pa,SELECT_CUSTOM_ATTRIBUTE:()=>Na,SLIDER_DOTS_ATTRIBUTE:()=>Ka,SMART_LIGHTBOX_ATTRIBUTE:()=>Ua,SOCIAL_SHARE_ATTRIBUTE:()=>Ga,STAR_RATING_ATTRIBUTE:()=>$a,TOC_ATTRIBUTE:()=>Wa,VIDEO_HLS_ATTRIBUTE:()=>Ha});var Ta="accordion",va="autovideo",ba="codehighlight",Sa="combobox",Aa="inject",Ea="copyclip",wa="displayvalues",Va="docs",Ma="favcustom",_a="formsubmit",Ia="inputactive",Ca="inputcounter",Ra="mirrorclick",Da="mirrorinput",Ba="modal",Oa="numbercount",Fa="list",La="queryparam",ka="rangeslider",Pa="scrolldisable",Na="selectcustom",Ka="sliderdots",Ua="smartlightbox",Ga="socialshare",$a="starrating",Wa="toc",Ya="readtime",qa="removequery",Ha="videohls";var Wr=t=>{if(xa(t))return t;if(Fe(t))return t.getTime();if(t)return parseFloat(t.replace(/[^0-9.-]+/g,""))};var Vo=(t,e=!0)=>t?t.split(",").reduce((r,n)=>{let i=n.trim();return(!e||i)&&r.push(i),r},[]):[];var za,ja;za=new WeakMap,ja=new WeakMap;var Io=Uo(_o(),1),tr=(t,e,r)=>{if(r==="date"||e==="date"||e==="time"||e==="datetime-local"||e==="month"||e==="week"){let n=At(t);return n===void 0||isNaN(n.getTime())?null:n}if(r==="number"||e==="number"||e==="range"){let n=Wr(t);return n===void 0||isNaN(n)?null:n}return t},Co=(t,e,r)=>{var o;typeof t!=typeof e&&(Fe(t)?e=At(e)||e:Fe(e)&&(t=At(t)||t));let n=Fe(t)?t.getTime():er(t)?t.toLowerCase():t,i=Fe(e)?e.getTime():er(e)?e.toLowerCase():e;if(r){let s=r/100,a=(o=Io.single(i.toString(),n.toString()))==null?void 0:o.score;return!!a&&a>=s}return n===i},Ro=(t,e,r)=>{var o,s;let n,i;return Fe(t)||Fe(e)?(n=(o=At(t))==null?void 0:o.getTime(),i=(s=At(e))==null?void 0:s.getTime()):er(t)||er(e)?(n=Wr(t),i=Wr(e)):(n=t,i=e),Rn(n)||Rn(i)?!1:r==="greater"?n>i:r==="greater-equal"?n>=i:r==="less"?n<i:r==="less-equal"?n<=i:!1};self.onmessage=t=>{let{filters:e,items:r}=t.data,n=e.groups.reduce((o,s)=>{let a=s.conditions.reduce((l,m)=>{let{op:f,value:c,fieldKey:g}=m;return!g||!f||f!=="empty"&&f!=="not-empty"&&(c===""||Array.isArray(c)&&!c.length)||l.push(m),l},[]);return a.length&&o.push(O(b({},s),{validConditions:a})),o},[]),i=r.filter(o=>{let s=a=>{let l=m=>{let f=g=>{let{op:d,filterMatch:R,fieldMatch:A}=m,C=o.fields[g];if(!C)return!1;let S=C.value,I=m.value;if(d==="empty")return Array.isArray(S)?!S.length:!S;if(d==="not-empty")return Array.isArray(S)?!!S.length:!!S;let D=d==null?void 0:d.startsWith("not-"),F=(v,P,N)=>{var be;let k=!1;return d==="equal"||d==="not-equal"?k=Co(v,N,m.fuzzyThreshold):d==="start"||d==="not-start"?k=v.toString().toLowerCase().startsWith(P.toLowerCase()):d==="end"||d==="not-end"?k=v.toString().toLowerCase().endsWith(P.toLowerCase()):d==="contain"||d==="not-contain"?k=v.toString().toLowerCase().includes(P.toLowerCase()):(d==="greater"||d==="greater-equal"||d==="less"||d==="less-equal")&&(k=Ro(v,N,d)),k&&(d==="equal"||d==="contain")&&((be=o.matchedFields)[g]||(be[g]=[]),o.matchedFields[g].push({fieldValue:v,filterValue:P})),D?!k:k},M=Array.isArray(I),B=Array.isArray(S);if(S===""||B&&!S.length)return D;if(M&&B){let v=P=>{let N=tr(P,m.type,C.type);return N===null?!1:A==="and"?S.every(k=>F(k,P,N)):S.some(k=>F(k,P,N))};return R==="and"?I.every(v):I.some(v)}if(M&&!B){let v=P=>{let N=tr(P,m.type,C.type);return N===null?!1:F(S,P,N)};return R==="and"?I.every(v):I.some(v)}if(!M&&B){let v=tr(I,m.type,C.type);return v===null?!1:A==="and"?S.every(P=>F(P,I,v)):S.some(P=>F(P,I,v))}if(!M&&!B){let v=tr(I,m.type,C.type);return v===null?!1:F(S,I,v)}return!1},c=m.fieldKey==="*"?Object.keys(o.fields):Vo(m.fieldKey);return m.fieldMatch==="and"?c.every(f):c.some(f)};return a.conditionsMatch==="or"?a.validConditions.some(l):a.validConditions.every(l)};return e.groupsMatch==="or"?n.some(s):n.every(s)});self.postMessage(i)};\n');
+}
+var Ur = navigator.hardwareConcurrency || 4;
+var qr = Array.from({ length: Ur }, () => new nt());
+var $t2 = qr.slice();
+var Kt = [];
+var Ut = (e, t) => {
+  let n = new AbortController(), { signal: i } = n, a = () => {
+    n.abort();
+    let o = Kt.shift();
+    o ? Ut(e, o) : $t2.push(e);
+  };
+  kn(e, "message", ((o) => {
+    t.resolve(o.data), a();
+  }), { signal: i, once: true }), kn(e, "error", ((o) => {
+    t.reject(o), a();
+  }), { signal: i, once: true }), e.postMessage(t.data);
+};
+var Wr = (e) => {
+  let t = $t2.pop();
+  t ? Ut(t, e) : Kt.push(e);
+};
+var Gr = (e) => new Promise((t, n) => {
+  Wr({ data: e, resolve: t, reject: n });
+});
+var Re = async (e, t, n) => {
+  let i = /* @__PURE__ */ new Map(), a = t.map((s) => {
+    i.set(s.id, s);
+    let { id: l, fields: u } = s;
+    return { id: l, fields: u, matchedFields: {} };
+  }), r = (await Gr({ items: a, filters: toRaw(e) })).map(({ id: s, matchedFields: l }) => {
+    let u = i.get(s);
+    return i.delete(s), n && u.highlight(l), u;
+  });
+  return n && i.forEach((s) => s.highlight({})), r;
+};
+var rt = (e, t, n = false) => {
+  let i = e.type, a = De(e), o = `${t}_${a}`, r = y(e, "tagfield"), s = y(e, "tagvalues", { filterInvalid: true }) ?? D.tagvalues.defaultValue, l = y(e, "filtermatch", { filterInvalid: true }), u = y(e, "fieldmatch", { filterInvalid: true }), d = y(e, "fuzzy"), p = !G(e, "showtag", "false"), c = we(e), m = $o(e, ne);
+  return Qt(m) && c && (m = Ae(m, c)), { id: o, fieldKey: t, type: i, op: a, value: m, filterMatch: l, fieldMatch: u, fuzzyThreshold: d, interacted: n, tagFieldDisplay: r, tagValuesDisplay: s, showTag: p };
+};
+var Wt2 = (e, t, n) => {
+  e.settingFilters = true;
+  for (let { fieldKey: i, value: a, op: o, type: r } of n) {
+    let s = `:is(input[type="${r}"], select, textarea)`, l = B("field", i), u = `:is(${B("operator", o)}, :not(${B("operator")}))`, d = [s, l, u].join(""), p = t.querySelector(d);
+    on(p) && Vo(p, a, ne);
+  }
+  e.settingFilters = false;
+};
+var De = (e) => {
+  let t = e.type, i = ["text", "password", "email", "tel", "url", "search", "color"].includes(t) ? "contain" : "equal";
+  return y(e, "operator", { filterInvalid: true }) || i;
+};
+var it = (e, t, n, i = false) => {
+  e.readingFilters = true;
+  let a = { id: n.toString(), conditions: [], conditionsMatch: y(t, "conditionsmatch", { filterInvalid: true }) ?? D.conditionsmatch.defaultValue };
+  for (let o of t.elements) {
+    if (!on(o)) continue;
+    let { type: r } = o;
+    if (r === "submit") continue;
+    let s = y(o, "field")?.trim();
+    if (!s) continue;
+    let l = rt(o, s, i);
+    a.conditions.some((u) => u.fieldKey === s && u.op === l.op) || a.conditions.push(l);
+  }
+  return e.readingFilters = false, a;
+};
+var Xt2 = (e, t, n) => {
+  let i = /* @__PURE__ */ new Map(), a = (r) => {
+    let s = q(r), l = j(r);
+    if (!s && !l) return;
+    let u = s ? Jr(e, r, n) : ei(e, r, n);
+    if (!u) return;
+    let d = watch(e.items, (c) => u({ items: c })), p = watch(e.filters, (c) => u({ filters: c }), { deep: true, immediate: true });
+    return () => {
+      d(), p();
+    };
+  };
+  for (let r of [...t.elements]) {
+    let s = a(r);
+    i.set(r, s);
+  }
+  let o = new MutationObserver((r) => {
+    for (let { addedNodes: s, removedNodes: l } of r) {
+      for (let u of s) {
+        if (!tn(u)) continue;
+        let d = [u, ...u.querySelectorAll("input, select")];
+        for (let p of d) {
+          if (i.has(p)) continue;
+          let c = a(p);
+          i.set(p, c);
+        }
+      }
+      for (let u of l) {
+        if (!tn(u)) continue;
+        let d = [u, ...u.querySelectorAll("input, select")];
+        for (let p of d) i.get(p)?.(), i.delete(p);
+      }
+    }
+  });
+  return o.observe(t, { childList: true, subtree: true }), () => {
+    o.disconnect();
+    for (let [, r] of i) r?.();
+  };
+};
+var Jr = (e, t, n) => {
+  let i = y(t, "field")?.trim();
+  if (!i) return;
+  let a = t.parentElement ?? void 0, o = v("facet-count", { scope: a });
+  j(o) && (o = null);
+  let r = t.closest(B("emptyfacet", "hide")), s = t.closest(B("emptyfacet", "add-class"));
+  if (!o && !r && !s) return;
+  let l = t.type, u = De(t), d = y(s, "emptyfacetclass"), c = l === "checkbox" && !be(t.name, t.form, ne)?.length ? y(t, "value") || "true" : y(t, "value") || t.value, m;
+  return (0, import_just_debounce.default)(async ({ filters: L = e.filters.value, items: h = e.items.value }) => {
+    await m, m = Qt2({ filters: L, items: h, fieldKey: i, op: u, groupIndex: n, value: c });
+    let E = await m;
+    if (!E) return;
+    let S = E.length > 0;
+    o && (o.textContent = `${E.length}`), r && (r.style.display = S ? "" : "none"), s && s.classList.toggle(d, !S);
+  }, 0);
+};
+var ei = (e, t, n) => {
+  let i = y(t, "field")?.trim();
+  if (!i) return;
+  let a = De(t), o = y(t, "emptyfacet", { filterInvalid: true }) === "hide", r = t.matches(I("facet-count")) || t.matches(B("facetcount"));
+  if (!o && !r) return;
+  let s = /* @__PURE__ */ new Map(), l;
+  return (0, import_just_debounce.default)(async ({ filters: d = e.filters.value, items: p = e.items.value }) => {
+    await l, l = Promise.all([...t.options].map(async (c) => {
+      let { value: m } = c;
+      if (!m) return;
+      s.has(c) || s.set(c, c.text);
+      let f = await Qt2({ filters: d, items: p, fieldKey: i, op: a, groupIndex: n, value: m });
+      if (!f) return;
+      let L = !f.length;
+      if (r) {
+        let h = s.get(c) || "";
+        c.text = `${h} (${f.length})`;
+      }
+      o && !c.selected && (c.hidden = L, c.disabled = L);
+    }));
+  }, 0);
+};
+var Qt2 = ({ filters: e, items: t, fieldKey: n, op: i, groupIndex: a, value: o }) => {
+  let r = structuredClone(toRaw(e)), s = r.groups[a];
+  if (!s) return;
+  let { conditions: l = [] } = s, u = l.findIndex((p) => p.fieldKey === n && p.op === i), d = l[u];
+  if (d) return Array.isArray(d.value) ? d.filterMatch === "and" ? d.value.push(o) : d.value = [o] : d.value = o, Re(r, t);
+};
+var Zt = (e, t) => {
+  let n = t.map((i, a) => ai(e, i, a));
+  return () => {
+    for (let i of n) i();
+  };
+};
+var ai = (e, t, n) => {
+  var d;
+  let i = /* @__PURE__ */ new Map(), a = Me(t), o = li(e, t, n, i), r = ui(e, n, i), s = y(t, "groupsmatch", { filterInvalid: true });
+  (d = e.filters.value).groupsMatch || (d.groupsMatch = s), e.filters.value.groups[n] = it(e, t, n);
+  let l = watch(() => e.filters.value.groups[n]?.conditions, (p) => {
+    e.readingFilters || Wt2(e, t, p);
+  }, { deep: true }), u = Xt2(e, t, n);
+  return () => {
+    a(), o(), r(), l(), u();
+  };
+};
+var li = (e, t, n, i) => {
+  let a = y(t, "filteron", { filterInvalid: true });
+  return a === "submit" ? kn(t, "submit", () => {
+    e.readingFilters = true, e.filters.value.groups[n] = it(e, t, n, true), e.readingFilters = false;
+  }) : kn(t, a, (o) => {
+    if (e.settingFilters) return;
+    let { target: r } = o;
+    if (!on(r)) return;
+    let s = y(r, "field")?.trim();
+    if (!s) return;
+    let l = rt(r, s, true), u = () => {
+      let m = e.filters.value.groups[n]?.conditions || [], f = m.findIndex((L) => L.fieldKey === s && L.op === l.op);
+      e.readingFilters = true, f >= 0 ? m[f] = l : m.push(l), e.readingFilters = false;
+    }, d = `${s}_${l.op}`, p = i.get(d);
+    p && clearTimeout(p);
+    let c = y(r, "debounce");
+    if (ie(c) && !isNaN(c)) {
+      let m = window.setTimeout(u, c);
+      i.set(d, m);
+      return;
+    }
+    u();
+  });
+};
+var ui = (e, t, n) => {
+  let { instance: i } = e, a = I("clear", { instance: i });
+  if (e.options.a11y !== false) {
+    let l = document.querySelectorAll(a);
+    for (let u of l) Dt(u);
+  }
+  let o = (l) => {
+    let u = l.closest(a);
+    if (!u) return;
+    let d = y(u, "field")?.trim(), p = e.filters.value.groups[t]?.conditions || [], c = d ? p.filter((m) => m.fieldKey === d) : p;
+    for (let m of c) {
+      n.delete(`${m.fieldKey}_${m.op}`);
+      let f = { value: Array.isArray(m.value) ? [] : "", interacted: false };
+      Object.assign(m, f);
+    }
+  }, r = kn(window, "click", (l) => {
+    let { target: u } = l;
+    u instanceof Element && o(u);
+  }), s;
+  return e.options.a11y !== false && (s = kn(window, "keydown", (l) => {
+    if (!vt(l)) return;
+    let { target: u } = l;
+    if (!tn(u)) return;
+    let d = u.closest(a);
+    d && ((l.key === " " || l.key === "Spacebar") && l.preventDefault(), d.click());
+  })), () => {
+    r(), s?.();
+  };
+};
+var en = (e) => {
+  let t = Object.keys(e.allFieldsData.value), n = e.filters.value.groups.flatMap((r) => r.conditions.flatMap((s) => s.fieldKey)), a = [.../* @__PURE__ */ new Set([...t, ...n])].map((r) => r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  return new RegExp(`^(?:([0-9]+)_)?(${a.join("|")})(?:_(${D.operator.values.join("|")}))?$`);
+};
+var tn2 = async (e) => {
+  let t = _.size > 1, n = await e.getAllSearchParams(t), i = en(e), a = n.filter(([o]) => o.match(i));
+  for (let [o, r] of a) {
+    let s = o.match(i);
+    if (!s) continue;
+    let l = s[1] ? parseInt(s[1]) : 0, u = s[2], d = s[3] ? s[3] : void 0, p = e.filters.value.groups[l]?.conditions.find((m) => m.fieldKey === u && m.op === d);
+    if (!p) continue;
+    let c = r;
+    try {
+      let m = JSON.parse(r);
+      (Array.isArray(m) && m.every(Qt) || Qt(m)) && (c = m);
+    } catch {
+    }
+    p.value = c, p.interacted = true;
+  }
+};
+var nn = async (e) => {
+  let t = _.size > 1, n = await e.getAllSearchParams(t), i = en(e);
+  for (let [o] of n) o.match(i) && await e.setSearchParam(o, null, { usePrefix: t });
+  let a = e.filters.value.groups.length > 1;
+  e.filters.value.groups.forEach((o, r) => {
+    o.conditions.forEach(({ fieldKey: s, op: l, value: u, interacted: d }) => {
+      let p = [a ? r : void 0, s, l].filter(ce).join("_"), c = Array.isArray(u);
+      if (!d || !u || c && !u.length) return;
+      let m = null;
+      if (c) try {
+        m = JSON.stringify(u);
+      } catch {
+      }
+      else m = u;
+      e.setSearchParam(p, m, { usePrefix: t });
+    });
+  });
+};
+var mi = { empty: "\u2205", "not-empty": "!\u2205", contain: "\u2283", "not-contain": "\u2285", start: "\u22C0", "not-start": "\u22C0\u0338", end: "\u22C1", "not-end": "\u22C1\u0338", equal: "=", "not-equal": "\u2260", less: "<", "less-equal": "\u2264", greater: ">", "greater-equal": "\u2265" };
+var an = (e, t) => {
+  let n = v("tag", { instance: e.instance });
+  if (!n) return;
+  let i = n.closest(I("tag-group")) || n.parentElement;
+  if (!i) return;
+  let a = i.parentNode;
+  if (!a) return;
+  let o = Array.from(i.children).indexOf(n), r = Array.from(a.children).indexOf(i);
+  i.remove(), n.remove();
+  let s = /* @__PURE__ */ new Map(), l = watch(e.filters, (u) => {
+    let d = /* @__PURE__ */ new Map();
+    u.groups.forEach((p) => {
+      let c = s.get(p.id), m = !!c;
+      if (!c) {
+        let h = F(i), E = v("tag-group-remove", { scope: h }), S = kn(E, "click", () => {
+          c?.remove();
+        });
+        c = { element: h, renderedTags: /* @__PURE__ */ new Map(), remove: () => {
+          c?.renderedTags.forEach((b) => b.remove());
+          let C = u.groups.length > 1;
+          if (t && C) {
+            let b = u.groups.findIndex((M) => M.id === p.id);
+            u.groups.splice(b, 1);
+          }
+        }, cleanup: () => {
+          S(), c?.renderedTags.forEach((C) => C.cleanup()), c?.element.remove(), s.delete(p.id);
+        } }, s.set(p.id, c);
+      }
+      let f = /* @__PURE__ */ new Map(), L = p.conditions.map((h) => {
+        let E = h.value;
+        if (Array.isArray(E) && h.tagValuesDisplay === "separate") return E.map((x) => {
+          let $ = `${h.id}:${x}`, k = c.renderedTags.get($), V = !!k;
+          if (!(h.showTag && !!h.interacted && !!x)) return k?.cleanup(), false;
+          if (!k) {
+            let W = F(n), er = v("tag-remove", { scope: W }), tr2 = kn(er, "click", () => k?.remove());
+            k = { element: W, remove: () => {
+              let nr = p.conditions.length > 1, Ee = p.conditions.findIndex((He) => He.id === h.id), Oe = p.conditions[Ee].value;
+              Array.isArray(Oe) && Oe.length > 1 ? p.conditions[Ee].value = Oe.filter((He) => He !== x) : t && nr ? p.conditions.splice(Ee, 1) : p.conditions[Ee].value = [];
+            }, cleanup: () => {
+              tr2(), k?.element.remove(), c.renderedTags.delete($);
+            } }, c.renderedTags.set($, k);
+          }
+          let X = { ...h, value: x };
+          if (sn2(X, k), !V) {
+            let W = c.element.children[o + f.size] || null;
+            c.element.insertBefore(k.element, W);
+          }
+          return f.set($, k), true;
+        }).some(Boolean);
+        let C = h.id, b = c.renderedTags.get(C), M = !!b;
+        if (!(h.showTag && !!h.interacted && !!h.value && (Array.isArray(h.value) ? !!h.value.length : true))) return b?.cleanup(), false;
+        if (!b) {
+          let A2 = F(n), x = v("tag-remove", { scope: A2 }), $ = kn(x, "click", () => b?.remove());
+          b = { element: A2, remove: () => {
+            let k = p.conditions.length > 1, V = p.conditions.findIndex((oe) => oe.id === h.id);
+            t && k ? p.conditions.splice(V, 1) : p.conditions[V].value = Array.isArray(h.value) ? [] : "";
+          }, cleanup: () => {
+            $(), b?.element.remove(), c.renderedTags.delete(C);
+          } }, c.renderedTags.set(C, b);
+        }
+        if (sn2(h, b), !M) {
+          let A2 = c.element.children[o + f.size] || null;
+          c.element.insertBefore(b.element, A2);
+        }
+        return f.set(C, b), true;
+      }).some(Boolean);
+      for (let [h, E] of c.renderedTags) f.has(h) || E.cleanup();
+      if (!L) {
+        c.cleanup();
+        return;
+      }
+      if (!m) {
+        let h = a.children[r + d.size] || null;
+        a.insertBefore(c.element, h);
+      }
+      d.set(p.id, c);
+    });
+    for (let [p, c] of s) d.has(p) || c.cleanup();
+  }, { deep: true });
+  return () => {
+    l();
+    for (let [, { cleanup: u }] of s) u();
+  };
+};
+var sn2 = (e, t) => {
+  let n = t.element, i = v("tag-field", { scope: n }), a = v("tag-operator", { scope: n }), o = v("tag-value", { scope: n }), r = new Map(D.operator.values.map((l) => {
+    let u = v(`tag-operator-${l}`, { scope: n });
+    if (u) return [l, u];
+  }).filter(ce));
+  i && (i.textContent = e.tagFieldDisplay || e.fieldKey);
+  let s = e.op;
+  if (s) {
+    if (r.get(s)) a?.remove(), r.delete(s);
+    else if (a) {
+      let u = mi[s];
+      a.textContent = u;
+    }
+    for (let [, u] of r) u.remove();
+  }
+  if (o) if (!e.value) o.remove();
+  else {
+    let l = e.value, u = y(o, "formatdisplay");
+    if (u) {
+      let p = u === "true" ? void 0 : u;
+      if (Array.isArray(e.value)) l = e.value.map((c) => {
+        let m = Xe(c, e.type);
+        return ie(m) ? m.toLocaleString(p) : K(m) ? m.toLocaleDateString(p) : c;
+      });
+      else {
+        let c = Xe(e.value, e.type);
+        ie(c) && (l = c.toLocaleString(p)), K(c) && (l = c.toLocaleDateString(p));
+      }
+    }
+    let d = Array.isArray(l) ? l.join(e.filterMatch === "and" ? " & " : " | ") : l;
+    o.textContent = d;
+  }
+};
+var ln = (e, t) => {
+  let n = e.options.filteringclass ?? "is-list-filtering", i = e.addHook("filter", async (p) => await Re(e.filters.value, p, e.highlight)), a = e.addHook("beforeRender", async (p) => {
+    if (e.triggeredHook === "filter") {
+      e.wrapperElement.classList.add(n);
+      let c = e.wrapperElement.getAnimations({ subtree: true });
+      try {
+        await Promise.all(c.map((m) => m.finished));
+      } catch {
+      }
+    }
+    return p;
+  }), o = e.addHook("afterRender", (p) => (e.wrapperElement.classList.remove(n), p)), r = It(e), s = !!v("condition-group", { scope: t[0] }), l = s ? Nt2(e, t[0]) : Zt(e, t), u = an(e, s), d = watch(e.filters, (0, import_just_debounce.default)(() => {
+    e.triggerHook("filter", { scrollToAnchor: e.hasInteracted.value, resetCurrentPage: e.hasInteracted.value }), e.showQuery && nn(e);
+  }, 0), { deep: true, immediate: true });
+  return tn2(e), () => {
+    i(), a(), o(), r(), u?.(), d(), l?.();
+  };
+};
+var Y = (e) => {
+  let { paginationNextCMSElement: t, paginationPreviousCMSElement: n, paginationCountElement: i, loadingSearchParamsData: a, cache: o } = e;
+  if (!t.value && !n.value) return Promise.resolve();
+  e.loading.value = true;
+  let r;
+  if (i) {
+    let [, s] = i.textContent?.split("/") || [];
+    s && (r = parseInt(s.trim()));
+  }
+  return e.loadingPaginatedItems = (async () => {
+    await a, r ? await un(e, r, o) : await yi(e, o), e.loading.value = false;
+  })(), e.loadingPaginatedItems;
+};
+var yi = async (e, t) => {
+  let n = e.currentPage.value;
+  if (n > 1 && await un(e, n, t), !e.paginationNextCMSElement.value) return;
+  let { href: i } = e.paginationNextCMSElement.value, a = [i], o = async (r) => {
+    let s = await Po(r, { cache: t });
+    if (!s) return;
+    let l = await lt(s, e);
+    !l || a.includes(l) || (a.push(l), await o(l));
+  };
+  await o(i);
+};
+var un = async (e, t, n) => {
+  if (!e.paginationNextCMSElement.value && !e.paginationPreviousCMSElement.value) return;
+  let i = e.currentPage.value;
+  if (!e.paginationSearchParam || !i) return;
+  let { origin: a, pathname: o } = window.location, r = (l) => `${a}${o}?${e.paginationSearchParam}=${l}`;
+  for (let l = i - 1; l >= 1; l--) {
+    let u = r(l), d = await Po(u, { cache: n });
+    if (!d) return;
+    await lt(d, e, "unshift");
+  }
+  let s = [];
+  for (let l = i + 1; l <= t; l++) s[l] = (async () => {
+    let u = s[l - 1], d = r(l), p = await Po(d, { cache: n });
+    await u, p && await lt(p, e);
+  })();
+  await Promise.all(s);
+};
+var lt = async (e, t, n = "push") => {
+  let a = e.querySelectorAll(P("wrapper"))[t.pageIndex];
+  if (!a) return;
+  let o = F2(a, "pagination-next")?.href, r = F2(a, "item"), { length: s } = r;
+  o && t.initialItemsPerPage !== s && !t.customItemsPerPage && (t.initialItemsPerPage = s, t.itemsPerPage.value = s);
+  let l = r.map(t.createItem).filter(ce);
+  return n === "push" ? t.items.value = [...t.items.value, ...l] : t.items.value = [...l, ...t.items.value], o;
+};
+var cn = (e) => {
+  Y(e).then(() => {
+    e.itemsPerPage.value = e.items.value.length;
+  });
+  let t = kn([...e.allPaginationPreviousElements.value, ...e.allPaginationNextElements.value], "click", (n) => {
+    n.preventDefault();
+  });
+  return () => {
+    t();
+  };
+};
+var pn = (e) => {
+  let t = effect(() => {
+    let n = e.hooks.filter.result.value;
+    if (e.visibleCountElement) {
+      let i = Math.min(e.itemsPerPage.value, n.length);
+      e.visibleCountElement.textContent = `${i}`;
+    }
+    if (e.visibleCountFromElement) {
+      let i = Math.min((e.currentPage.value - 1) * e.itemsPerPage.value + 1, n.length);
+      e.visibleCountFromElement.textContent = `${i}`;
+    }
+    if (e.visibleCountToElement) {
+      let i = Math.min(e.currentPage.value * e.itemsPerPage.value, n.length);
+      e.visibleCountToElement.textContent = `${i}`;
+    }
+  });
+  return () => {
+    t.effect.stop();
+  };
+};
+var dn = (e) => {
+  e.addHook("pagination", (i) => i.slice(0, e.itemsPerPage.value)), Y(e);
+  let t = ut(e), n = ct(e);
+  return () => {
+    t(), n();
+  };
+};
+var ut = (e) => {
+  let t;
+  e.options.a11y !== false && e.allPaginationNextElements.value.forEach((a) => Dt(a));
+  let n = I("pagination-next", { instance: e.instance }), i = _n(n, { click: ({ event: a, el: o }) => {
+    if (!tn(o)) return;
+    a.preventDefault();
+    let r = y(o, "loadcount") || e.options.loadcount;
+    r === "all" ? t || (t = watch(e.items, (s) => {
+      e.itemsPerPage.value = s.length;
+    }, { immediate: true })) : e.itemsPerPage.value += jo(r, e.initialItemsPerPage), e.triggerHook("pagination");
+  }, keydown: ({ event: a, el: o }) => {
+    e.options.a11y !== false && vt(a) && ((a.key === " " || a.key === "Spacebar") && a.preventDefault(), o.click());
+  } });
+  return () => {
+    i(), t?.();
+  };
+};
+var ct = (e) => {
+  let t = effect(() => {
+    let n = e.itemsPerPage.value >= e.hooks.filter.result.value.length;
+    if (e.allPaginationNextElements.value.forEach((i) => {
+      i.style.display = n ? "none" : "", i.setAttribute("aria-hidden", n ? "true" : "false"), i.setAttribute("tabindex", n ? "-1" : "0");
+    }), e.paginationCountElement) {
+      let i = Math.ceil(e.hooks.filter.result.value.length / e.initialItemsPerPage), a = Math.ceil(e.itemsPerPage.value / e.initialItemsPerPage);
+      e.paginationCountElement.innerText = `${a} / ${i}`, e.paginationCountElement.setAttribute("aria-label", `Page ${a} of ${i}`);
+    }
+  });
+  return () => {
+    t.effect.stop();
+  };
+};
+var mn = (e) => {
+  if (!e.listElement) return;
+  let t = Ii(e);
+  e.addHook("pagination", (s) => s.slice(0, e.itemsPerPage.value)), Y(e);
+  let n = functionThrottle(async () => {
+    if (!e.listElement) return;
+    let { innerHeight: s } = window, { bottom: l } = e.listElement.getBoundingClientRect(), u = t * s;
+    l > 0 && l <= u && e.itemsPerPage.value < e.items.value.length && (e.itemsPerPage.value += e.initialItemsPerPage, e.triggerHook("pagination"));
+  }, 10), i, a = new IntersectionObserver((s) => {
+    for (let { isIntersecting: l } of s) l ? i || (i = kn(window, "scroll", n)) : (i?.(), i = void 0);
+  });
+  a.observe(e.listElement);
+  let o = ut(e), r = ct(e);
+  return () => {
+    a.disconnect(), i?.(), o(), r();
+  };
+};
+var Ii = (e) => 1 - (e.options.threshold ?? -20) / 100;
+var bn = async (e) => {
+  let { currentPage: t, itemsPerPage: n, paginationWrapperElement: i } = e;
+  if (!i) return;
+  e.addHook("pagination", (h) => {
+    let E = n.value, S = (t.value - 1) * E, C = S + E;
+    return h.slice(S, C);
+  });
+  let a = watch(e.currentPage, () => {
+    e.triggeredHook || e.triggerHook("pagination", { scrollToAnchor: true }), e.showQuery && e.setSearchParam("page", t.value.toString(), { useSearchParamsPrefix: true });
+  }, {}), o = watch(e.itemsPerPage, () => {
+    e.triggerHook("pagination", { scrollToAnchor: true });
+  });
+  Y(e), await e.loadingSearchParamsData;
+  let [r, s] = yn(e, "pageboundary"), [l, u] = yn(e, "pagesiblings"), d = v("page-button", { scope: i }), p = v("page-dots", { scope: i });
+  p ? p.remove() : (p = document.createElement("div"), p.textContent = "...");
+  let c;
+  if (d) {
+    let { parentElement: h } = d;
+    d.remove(), h && (c = Oi(e, h, d, p, l, r));
+  }
+  let m = Bi(e), f = $i(e), L = Ni(e);
+  return () => {
+    s?.(), u?.(), c?.(), m?.(), L?.(), f(), a(), o();
+  };
+};
+var Oi = (e, t, n, i, a, o) => {
+  let { currentPage: r, totalPages: s } = e, l = /* @__PURE__ */ new Map(), u = effect(() => {
+    let c = a.value * 2 + 1, f = o.value * 2 + c + 2, L = r.value - 1 < f - c, h = s.value - r.value < f - c, E = [...l];
+    for (let S = 1; S <= f; S++) {
+      let [C, b] = E[S - 1] || [], [M] = E[S - 2] || [];
+      if (S > s.value) {
+        C && (C.remove(), E[S - 1] = void 0);
+        continue;
+      }
+      let T;
+      s.value <= f ? T = S : L ? S > f - o.value ? T = s.value - (f - S) : S === f - o.value ? T = null : T = S : h ? S < o.value + 1 ? T = S : S === o.value + 1 ? T = null : T = s.value - (f - S) : S < o.value + 1 ? T = S : S > f - o.value ? T = s.value - (f - S) : S === o.value + 1 || S === f - o.value ? T = null : T = r.value + (S - (o.value + 1) - (1 + a.value));
+      let A2;
+      b !== T && (C?.remove(), A2 = Hi(n, i, T, e), E[S - 1] = [A2, T], M ? t.insertBefore(A2, M.nextSibling) : t.appendChild(A2), A2.style.opacity = "");
+      let x = A2 || C;
+      x && (T === r.value ? (x.classList.add(Ht), x.setAttribute("aria-current", "page")) : (x.classList.remove(Ht), x.removeAttribute("aria-current")));
+    }
+    l = new Map([...E.filter(ce)]);
+  }), d = I("page-button"), p = _n(d, { click: ({ event: c, el: m }) => {
+    c.preventDefault();
+    let f = l.get(m);
+    f && (e.currentPage.value = f);
+  }, keydown: ({ event: c, el: m }) => {
+    e.options.a11y !== false && vt(c) && ((c.key === " " || c.key === "Spacebar") && c.preventDefault(), m.click());
+  } }, { root: t });
+  return () => {
+    u.effect.stop(), p();
+  };
+};
+var Hi = (e, t, n, { paginationSearchParam: i }) => {
+  if (!n) return F(t);
+  let a = F(e);
+  return a.classList.remove(Ht), a.textContent = `${n}`, sn(a) && i && (a.href = `?${i}=${n}`), a;
+};
+var Ni = ({ paginationCountElement: e, currentPage: t, totalPages: n }) => {
+  if (!e) return;
+  let i = effect(() => {
+    e.setAttribute("aria-label", `Page ${t.value} of ${n.value}`), e.textContent = `${t.value} / ${n.value}`;
+  });
+  return () => i.effect.stop();
+};
+var Bi = (e) => {
+  if (!e.paginationWrapperElement) return;
+  let t = effect(() => {
+    e.paginationWrapperElement.style.display = e.hooks.pagination.result.value.length > 0 ? "" : "none";
+  });
+  return () => t.effect.stop();
+};
+var $i = (e) => {
+  let t = (r, s) => {
+    let l = y(r, "paginationdisabledclass");
+    r.style.display = "", r.classList[s ? "remove" : "add"](l), r.setAttribute("aria-disabled", s ? "false" : "true"), r.setAttribute("tabindex", s ? "0" : "-1");
+  }, n = effect(() => {
+    e.allPaginationPreviousElements.value.forEach((r) => {
+      let s = e.currentPage.value !== 1;
+      t(r, s), sn(r) && (r.href = `?${e.paginationSearchParam}=${e.currentPage.value - 1}`);
+    }), e.allPaginationNextElements.value.forEach((r) => {
+      let s = e.currentPage.value !== e.totalPages.value;
+      t(r, s), sn(r) && (r.href = `?${e.paginationSearchParam}=${e.currentPage.value + 1}`);
+    });
+  });
+  e.options.a11y !== false && (e.allPaginationPreviousElements.value.forEach((r) => Dt(r)), e.allPaginationNextElements.value.forEach((r) => Dt(r)));
+  let i = P("pagination-next"), a = P("pagination-previous"), o = _n(`:is(${i}, ${a})`, { click: ({ event: r, el: s }) => {
+    if (j2(s) !== e.instance) return;
+    r.preventDefault();
+    let u = s.matches(i) ? e.currentPage.value + 1 : e.currentPage.value - 1;
+    !u || u < 1 || u > e.totalPages.value || (e.currentPage.value = u);
+  }, keydown: ({ event: r, el: s }) => {
+    e.options.a11y !== false && vt(r) && j2(s) === e.instance && ((r.key === " " || r.key === "Spacebar") && r.preventDefault(), s.click());
+  } });
+  return () => {
+    n.effect.stop(), o();
+  };
+};
+var yn = (e, t) => {
+  let n = e.options[t], i = tr(n).map(parseInt), a = ref(i[0]), o = () => {
+    let s = Do(), l = bt[s];
+    for (let u = l; u >= 0; u--) {
+      let d = i[u];
+      if (ie(d)) {
+        a.value = d;
+        break;
+      }
+    }
+  }, r = kn(window, "resize", (0, import_just_debounce.default)(o, 100));
+  return o(), [a, r];
+};
+var Tn = (e, t) => {
+  let n = e.options.loadingclass ?? "is-list-loading";
+  (e.options.resetix ?? false) && e.webflowModules.add("ix2");
+  let a = pn(e), o = t === "all" ? cn(e) : t === "more" ? dn(e) : t === "infinite" ? mn(e) : bn(e), r = e.addHook("beforeRender", async (l) => {
+    if (e.triggeredHook === "pagination") {
+      e.wrapperElement.classList.add(n);
+      let u = e.wrapperElement.getAnimations({ subtree: true });
+      try {
+        await Promise.all(u.map((d) => d.finished));
+      } catch {
+      }
+    }
+    return l;
+  }), s = e.addHook("afterRender", (l) => (e.wrapperElement.classList.remove(n), l));
+  return async () => {
+    (await o)?.(), r(), s(), a();
+  };
+};
+var Sn2 = (e) => {
+  let t = /* @__PURE__ */ new Set(), n = effect(() => {
+    let i = false;
+    Promise.all(e.items.value.map(async (a) => {
+      if (t.has(a)) return;
+      t.add(a);
+      let o = R("nest-target", { scope: a.element });
+      o.length && (await Promise.all(o.map(async (r) => ji(e, a, r))), i = true);
+    })).then(() => {
+      i && triggerRef(e.items);
+    });
+  });
+  return () => {
+    n.effect.stop(), t.clear();
+  };
+};
+var ji = (e, t, n) => {
+  if (!t.href) return;
+  let i = y(n, "nest");
+  if (!i) return;
+  let a = t.element.querySelector(`${I("nest-slugs")}${B("nest", i)}`);
+  return t.nesting = new Promise((o) => {
+    if (a) {
+      let r = tr(a.textContent);
+      zi(e, t, n, r, i).then(o);
+    } else Ln(e, t, n, i).then(o);
+  }), t.nesting;
+};
+var zi = async (e, t, n, i, a) => {
+  if (!i.length || !t.href) return;
+  let o = [..._.values()].find((l) => l !== e && l.instance === a);
+  if (!o) return;
+  let r = o.items.value.filter(({ href: l }) => {
+    if (!l) return false;
+    try {
+      let u = new URL(l), [d] = u.pathname.match(/[^/]+(?=\/$|$)/g) || [];
+      return d && i.includes(d);
+    } catch {
+      return false;
+    }
+  }), s = F(o.wrapperElement, false);
+  if (r.length) {
+    let l = o.listElement ? F(o.listElement, false) : document.createElement("div");
+    await Promise.resolve();
+    let u = await Promise.all(r.map(async (d) => (await d.nesting, F(d.element))));
+    l.append(...u), s.append(l);
+  } else {
+    let l = o.emptyElement.value;
+    l || (await o.loadingPaginationElements, l = o.emptyElement.value), l && s.append(l);
+  }
+  n.append(s), t.collectFields();
+};
+var Ln = async (e, t, n, i) => {
+  if (!t.href) return;
+  let a = await Po(t.href, { cache: e.cache });
+  if (!a) return;
+  let o = v("wrapper", { scope: a, instance: i }) || v("list", { scope: a, instance: i });
+  if (!o) return;
+  let r = F2(o, "wrapper");
+  if (!r) return;
+  let l = re(a).indexOf(r);
+  if (l === -1) return;
+  let u = new le(r, l, false);
+  if (u.emptyElement.value) {
+    n.append(u.emptyElement.value);
+    return;
+  }
+  if (!u.items.value.length) return;
+  let d = xn(a);
+  await Promise.all(u.items.value.map(async (p) => {
+    let c = R("nest-target", { scope: p.element });
+    c.length && await Promise.all(c.map(async (m) => {
+      let f = y(m, "nest");
+      f && (await Ln(e, p, m, f), t.collectFields());
+    }));
+  })), await d, n.append(r), t.collectFields();
+};
+var Cn = (e, t, n) => {
+  let i = v("previous-empty", { instance: e.instance }), a = v("next-empty", { instance: e.instance });
+  i?.remove(), a?.remove();
+  let o = !!e.loadingPaginatedItems, r, s;
+  e.loadingPaginatedItems?.then(() => {
+    o = false, l(e.items.value);
+  });
+  let l = (d) => {
+    if (r && s) return;
+    let p = window.location.origin + window.location.pathname, c = d.findIndex((m) => m.href === p);
+    if (c === -1 && !o && (i && t?.append(i), a && n?.append(a)), c !== -1) {
+      if (!r) if (r = d[c - 1], r) {
+        let m = F(r.element);
+        i?.remove(), t?.append(m);
+      } else !o && i && t?.append(i);
+      if (!s) if (s = d[c + 1], s) {
+        let m = F(s.element);
+        a?.remove(), n?.append(m);
+      } else !o && a && n?.append(a);
+    }
+  };
+  return watch(e.items, l, { immediate: true });
+};
+var xn2 = (e, t) => {
+  e.webflowModules.add("slider");
+  let n = t.map((i) => Qi(e, i));
+  return () => {
+    for (let i of n) i?.();
+  };
+};
+var Qi = (e, t) => {
+  if (!j(t)) return;
+  let n = /* @__PURE__ */ new Map();
+  return e.addHook("render", (i = []) => {
+    let a = /* @__PURE__ */ new Set();
+    for (let o of i) {
+      let r = R("select-value", { scope: o.element });
+      for (let s of r) a.add(s.innerText);
+    }
+    for (let o of a) {
+      if (n.has(o)) continue;
+      let r = new Option(o, o);
+      t.options.add(r), n.set(o, r);
+    }
+    for (let [o, r] of n) a.has(o) || (r?.remove(), n.delete(o));
+  }), () => {
+    n.clear();
+  };
+};
+var Mn2 = (e, t) => {
+  e.webflowModules.add("slider");
+  let n = t.map((i) => Ji(e, i));
+  return () => {
+    for (let i of n) i?.();
+  };
+};
+var Ji = (e, t) => {
+  let n = t.closest(`.${Ft.slider}`);
+  if (!n) return;
+  let i = n.querySelector(`.${Ft.sliderMask}`);
+  if (!i) return;
+  let a = n.querySelectorAll(`.${Ft.slide}`);
+  if (!a.length) return;
+  let o = a[0].classList.value;
+  for (let s of a) s.remove();
+  let r = /* @__PURE__ */ new Map();
+  return e.addHook("beforeRender", (s = []) => {
+    for (let l of s) {
+      if (r.has(l.id)) continue;
+      l.currentIndex = void 0, l.element.removeAttribute(Mn);
+      let u = document.createElement("div");
+      u.setAttribute("class", o), u.appendChild(l.element), i.appendChild(u), r.set(l.id, u);
+    }
+    for (let [l, u] of r) s.some((d) => d.id === l) || (u?.remove(), r.delete(l));
+    return e.renderedItems.clear(), [];
+  }), e.triggerHook("beforeRender"), () => {
+    r.clear();
+  };
+};
+var Fn2 = (e, t) => {
+  let n = ref(), i = /* @__PURE__ */ new Map(), a = e.flatMap((s) => {
+    let l = y(s, "field")?.trim();
+    if (!l) return;
+    let u = G(s, "reverse", "true"), d = y(s, "ascclass"), p = y(s, "descclass"), c = ref();
+    s.setAttribute(Mn, Dn.columnheader), s.setAttribute(vn, "0"), t.options.a11y !== false && Dt(s), i.set(s, { fieldKey: l, reverse: u, currentDirection: c });
+    let m = computed(() => n.value !== s ? "none" : c.value === "asc" ? uo.ascending : uo.descending), f = effect(() => {
+      s.setAttribute(co, m.value);
+    }), L = computed(() => n.value !== s ? null : c.value === "asc" ? d : p), h = effect(() => {
+      s.classList.remove(d, p), L.value && s.classList.add(L.value);
+    });
+    return [() => f.effect.stop(), () => h.effect.stop()];
+  }).filter(ce), o = I("sort-trigger", { instance: t.instance }), r = _n(o, { click: ({ event: s, el: l }) => {
+    let u = i.get(l);
+    u && (s.preventDefault(), n.value = l, u.currentDirection.value = lo(u.currentDirection.value, u.reverse), t.sorting.value = { fieldKey: u.fieldKey, direction: u.currentDirection.value, interacted: true });
+  }, keydown: ({ event: s, el: l }) => {
+    i.has(l) && t.options.a11y !== false && vt(s) && ((s.key === " " || s.key === "Spacebar") && s.preventDefault(), l.click());
+  } });
+  return () => {
+    r();
+    for (let s of a) s();
+  };
+};
+var lo = (e, t) => e ? e === "desc" ? "asc" : "desc" : t ? "desc" : "asc";
+var Hn = (e, t) => {
+  let n = e.querySelector(`.${Wt.dropdownToggle}`), i = e.querySelector(`.${Wt.dropdownList}`);
+  if (!n || !i) return;
+  yo(n, i);
+  let a = ref(), o = go(n, a), r = ho(i, a);
+  if (!r) return;
+  let s = _n("a", { click: ({ event: l, el: u }) => {
+    l.preventDefault();
+    let d = u, p = r.get(d);
+    !p || a.value?.element === d || (a.value = p, t.sorting.value = { fieldKey: p.fieldKey, direction: p.direction, interacted: true }, vo(n));
+  } }, { root: i });
+  return () => {
+    o?.(), s();
+  };
+};
+var ho = (e, t) => {
+  let n = /* @__PURE__ */ new Map(), i = [...e.querySelectorAll("a")];
+  if (i.length) {
+    for (let a of i) {
+      a.setAttribute(Mn, Dn.option);
+      let o = y(a, "field")?.trim(), r, s;
+      o && (o.endsWith("-asc") ? (s = "asc", r = o.slice(0, -4)) : o.endsWith("-desc") ? (s = "desc", r = o.slice(0, -5)) : (s = "asc", r = o));
+      let l = effect(() => {
+        t.value?.element === a ? (a.setAttribute(Un, "true"), a.classList.add(Ht)) : (a.removeAttribute(Un), a.classList.remove(Ht));
+      });
+      n.set(a, { element: a, fieldKey: r, direction: s, cleanup: () => l.effect.stop() });
+    }
+    return n;
+  }
+};
+var go = (e, t) => {
+  let n = v("dropdown-label", { scope: e });
+  if (!n) return;
+  let i = n.innerHTML, a = effect(() => {
+    if (!t.value) {
+      n.innerHTML = i;
+      return;
+    }
+    n.innerHTML = t.value.element.innerHTML;
+  });
+  return () => a.effect.stop();
+};
+var yo = (e, t) => {
+  e.setAttribute(Kn, Dn.listbox), t.setAttribute(Mn, Dn.listbox), t.setAttribute(Fn, "false");
+};
+var Nn = (e) => {
+  let t = Object.keys(e.allFieldsData.value);
+  return new RegExp(`sort_(${t.join("|")})$`);
+};
+var Bn = async (e) => {
+  let t = _.size > 1, n = await e.getAllSearchParams(t), i = Nn(e), a = n.find(([u, d]) => u.match(i) && (d === "asc" || d === "desc"));
+  if (!a) return;
+  let [o, r] = a, s = o.match(i);
+  if (!s) return;
+  let l = s[1];
+  e.sorting.value.fieldKey = l, e.sorting.value.direction = r, e.sorting.value.interacted = true;
+};
+var $n = async (e) => {
+  let t = _.size > 1, n = await e.getAllSearchParams(t), i = Nn(e);
+  for (let [s] of n) s.match(i) && await e.setSearchParam(s, null, { usePrefix: t });
+  let { fieldKey: a, direction: o } = e.sorting.value;
+  if (!a || !o) return;
+  let r = `sort_${a}`;
+  e.setSearchParam(r, o, { usePrefix: t });
+};
+var Un2 = (e, t) => {
+  let n = (s = false) => {
+    t.sorting.value = Eo(e.value, s);
+  }, i = kn(e, "change", () => n(true));
+  n();
+  let a = e.closest("form"), r = G(e, "allowsubmit", "true") ? kn(a, "submit", vo2) : void 0;
+  return () => {
+    i(), r?.();
+  };
+};
+var vo2 = (e) => (e.preventDefault(), e.stopImmediatePropagation(), false);
+var Eo = (e, t = false) => {
+  let n, i;
+  return e.endsWith("-asc") ? (i = "asc", n = e.slice(0, -4)) : e.endsWith("-desc") ? (i = "desc", n = e.slice(0, -5)) : (i = "asc", n = e), { fieldKey: n, direction: i, interacted: t };
+};
+var qn = (e, { fieldKey: t, direction: n }) => !!n && !!t && e.some(({ fields: o }) => t in o) ? [...e].sort((o, r) => {
+  let s = o.fields[t], l = r.fields[t];
+  if (!s) return 1;
+  if (!l) return -1;
+  if (s.type === "number" && l.type === "number") {
+    let u = pe(s.value), d = pe(l.value);
+    return isNaN(u) ? 1 : isNaN(d) ? -1 : n === "asc" ? u - d : d - u;
+  }
+  if (s.type === "date" && l.type === "date") {
+    let u = pe(s.value).getTime(), d = pe(l.value).getTime();
+    return n === "asc" ? u - d : d - u;
+  }
+  if (s.type === "text" && l.type === "text") {
+    let u = pe(s.value), d = pe(l.value), p = { numeric: true, sensitivity: "base" };
+    return n === "asc" ? u.localeCompare(d, void 0, p) : d.localeCompare(u, void 0, p);
+  }
+  return 0;
+}) : void 0;
+var pe = (e) => {
+  let [t] = Array.isArray(e) ? e : [e];
+  return t;
+};
+var Wn = (e, t) => {
+  let n = e.options.sortingclass ?? "is-list-sorting", [i] = t, a = j(i), o = i.closest(`.${Wt.dropdown}`), r = a ? Un2(i, e) : o ? Hn(o, e) : Fn2(t, e), s = e.addHook("sort", (p) => qn(p, e.sorting.value)), l = e.addHook("beforeRender", async (p) => {
+    if (e.triggeredHook === "sort") {
+      e.wrapperElement.classList.add(n);
+      let c = e.wrapperElement.getAnimations({ subtree: true });
+      try {
+        await Promise.all(c.map((m) => m.finished));
+      } catch {
+      }
+    }
+    return p;
+  }), u = e.addHook("afterRender", (p) => (e.wrapperElement.classList.remove(n), p)), d = watch(e.sorting, (0, import_just_debounce.default)(() => {
+    e.triggerHook("sort", { scrollToAnchor: e.hasInteracted.value, resetCurrentPage: e.hasInteracted.value }), e.showQuery && $n(e);
+  }, 0), { deep: true, immediate: true });
+  return Bn(e), () => {
+    r?.(), s(), l(), u(), d();
+  };
+};
+var jn = /* @__PURE__ */ new WeakSet();
+var zn = (e, t) => {
+  let { interactiveItems: n, nonInteractiveItems: i } = t.reduce((o, r) => {
+    let s = y(r, "position") - 1, l = y(r, "repeat"), u = y(r, "interactive"), d;
+    if (jn.has(r)) {
+      let p = F(r);
+      d = e.createItem(p);
+    } else d = e.createItem(r);
+    return jn.add(r), u ? o.interactiveItems.push({ position: s, item: d }) : o.nonInteractiveItems.push({ position: s, item: d, repeat: l }), o;
+  }, { interactiveItems: [], nonInteractiveItems: [] });
+  n.sort((o, r) => o.position - r.position), i.sort((o, r) => o.position - r.position);
+  let a = e.addHook("static", (o) => {
+    let r = [...o];
+    for (let { position: s, item: l, repeat: u } of i) {
+      if (r.splice(s, 0, l), !u) continue;
+      let d = s + u;
+      for (; d < r.length; ) {
+        let p = F(l.element), c = e.createItem(p);
+        r.splice(d, 0, c), d += u;
+      }
+    }
+    return r;
+  });
+  for (let { position: o, item: r } of n) e.items.value.splice(o, 0, r);
+  return n.length ? triggerRef(e.items) : i.length && e.triggerHook("static"), a;
+};
+var Yn = (e, t) => {
+  e.webflowModules.add("tabs");
+  let n = t.map((i) => Mo2(e, i));
+  return () => {
+    for (let i of n) i?.();
+  };
+};
+var Mo2 = (e, t) => {
+  let n = t.closest(`.${$t.tabs}`);
+  if (!n) return;
+  let i = n.querySelector(`.${$t.tabsMenu}`);
+  if (!i) return;
+  let a = n.querySelector(`.${$t.tabsContent}`);
+  if (!a) return;
+  let o = n.querySelectorAll(`.${$t.tabLink}`);
+  if (!o.length) return;
+  let r = n.querySelectorAll(`.${$t.tabPane}`);
+  if (!r.length) return;
+  let s = o[0].classList.value, l = r[0].classList.value;
+  for (let d of [...o, ...r]) d.remove();
+  let u = /* @__PURE__ */ new Map();
+  return e.addHook("beforeRender", (d = []) => {
+    for (let p of d) {
+      if (u.has(p.id)) continue;
+      p.currentIndex = void 0, p.element.removeAttribute(Mn);
+      let c = document.createElement("div");
+      c.setAttribute("class", s);
+      let m = document.createElement("div");
+      m.setAttribute("class", l);
+      let f = v("tab-link", { scope: p.element });
+      f ? f = F(f) : (f = document.createElement("div"), f.innerHTML = 'Missing <strong>ad-list-element="tab-link"</strong>'), c.appendChild(f), i.appendChild(c), m.appendChild(p.element), a.appendChild(m), u.set(p.id, { tabLink: c, tabPane: m });
+    }
+    for (let [p, { tabLink: c, tabPane: m }] of u) d.some((f) => f.id === p) || (c?.remove(), m?.remove(), u.delete(p));
+    return [...u.values()].forEach(({ tabLink: p, tabPane: c }, m) => {
+      let f = `Tab ${m}`;
+      p.dataset.wTab = f, c.dataset.wTab = f;
+    }), e.renderedItems.clear(), [];
+  }), e.triggerHook("beforeRender"), () => {
+    u.clear();
+  };
+};
+var Xn = (e) => {
+  let t = F2(e, "wrapper");
+  if (!t) return;
+  let n = _.get(t);
+  if (n) return n;
+  let a = re().indexOf(t);
+  if (a === -1) return;
+  let o = zo(t, K2, Se, { includeGlobal: false }), r = new le(t, a, true, o);
+  return _.set(t, r), r;
+};
+var Qn = (e) => {
+  let { instance: t } = e, n = /* @__PURE__ */ new Set(), i = R("filters", { instance: t }).filter(rn);
+  if (i.length) {
+    let E = ln(e, i);
+    n.add(E);
+  }
+  let a = R("sort-trigger", { instance: t });
+  if (a.length) {
+    let E = Wn(e, a);
+    n.add(E);
+  }
+  let { load: o } = e.options;
+  if (o && (o === "all" || o === "more" || o === "infinite" || o === "pagination")) {
+    let E = Tn(e, o);
+    n.add(E);
+  }
+  let { combine: r } = e.options;
+  if (r) {
+    let E = Et(e, r);
+    n.add(E);
+  }
+  let s = Sn2(e);
+  n.add(s);
+  let l = I("list", { instance: t }), u = I("item", { instance: t }), d = `:is(${u}):not(:is(${l}) :is(${u}))`, p = document.querySelectorAll(d);
+  if (p.length) {
+    let E = zn(e, [...p]);
+    n.add(E);
+  }
+  let c = R("slider", { instance: t });
+  if (c.length) {
+    let E = Mn2(e, c);
+    n.add(E);
+  }
+  let m = R("tabs", { instance: t });
+  if (m.length) {
+    let E = Yn(e, m);
+    n.add(E);
+  }
+  let f = R("select", { instance: t });
+  if (f.length) {
+    let E = xn2(e, f);
+    n.add(E);
+  }
+  let L = v("previous-item", { instance: t }), h = v("next-item", { instance: t });
+  return (L || h) && Cn(e, L, h), () => {
+    for (let E of n) E?.();
+    n.clear(), e.destroy();
+  };
+};
+var gt2 = async () => {
+  await rr();
+  let e = Nt(), t = Bt(() => e.run()), n = { activeCount: 0, disabledCount: 0, guardFailedCount: 0, lastNonActivationReason: null }, i = async () => {
+    let o = R("list"), r = [];
+    for (let u of o) {
+      let d = await Xt({ el: u, moduleKey: K2, includeGlobal: false, guardsRegistry: {}, readOptions: () => zo(u, K2, Se, { includeGlobal: false }), action: () => {
+        let p = P("list"), c = [], m = u.parentElement?.closest(p);
+        for (; m; ) c.push(m), m = m.parentElement?.closest(p);
+        if (c.length > 0) {
+          let h = j2(u);
+          if (c.some((S) => {
+            let C = j2(S);
+            return h === C;
+          })) return;
+        }
+        let L = Xn(u);
+        L && r.push(L);
+      } });
+      d.ok ? n.activeCount += 1 : d.reason === "disabled" ? (n.disabledCount += 1, n.lastNonActivationReason = "disabled") : d.reason === "guard-failed" && (n.guardFailedCount += 1, n.lastNonActivationReason = "guard-failed");
+    }
+    let s = r.filter(ce);
+    return s.map(Qn).forEach((u) => e.add(u)), s;
+  };
+  return { result: { lists: await i(), diagnostics: n }, destroy() {
+    t();
+  }, async restart() {
+    e.run(), e = Nt(), t = Bt(() => e.run()), await i();
+  } };
+};
+var Vo2 = "0.1.1";
+var Bu = wn({ key: K2, init: async (e) => {
+  let t = Nt(), n = await gt2();
+  n && typeof n.destroy == "function" && t.add(() => {
+    try {
+      n.destroy();
+    } catch {
+    }
+  });
+  let i = { key: K2, destroy: () => t.run() };
+  return n && typeof n.restart == "function" ? { ...i, restart: async () => {
+    try {
+      await n.restart();
+    } catch {
+    }
+  } } : i;
+} });
+export {
+  We as ELEMENTS,
+  le as List,
+  ge as ListItem,
+  K2 as MODULE_KEY,
+  D as SETTINGS,
+  Bu as default,
+  gt2 as init,
+  Vo2 as version
+};
+/*! Bundled license information:
+
+@vue/shared/dist/shared.esm-bundler.js:
+  (**
+  * @vue/shared v3.5.27
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **)
+
+@vue/reactivity/dist/reactivity.esm-bundler.js:
+  (**
+  * @vue/reactivity v3.5.27
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **)
+*/
+//# sourceMappingURL=dist-M6QCD7TL.js.map