sandstone-cli 2.3.2 → 2.4.1

package/lib/index.js

@@ -5,25 +5,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -4263,170 +4281,1996 @@ var require_permutations = __commonJS((exports, module) => {
       if (i < r)
         cycles[i] = n - i;
     }
-    i = r;
-    return new Iterator(function next() {
-      if (first) {
-        first = false;
-        indicesToItems(subsequence, array, indices, r);
-        return { value: subsequence, done: false };
+    i = r;
+    return new Iterator(function next() {
+      if (first) {
+        first = false;
+        indicesToItems(subsequence, array, indices, r);
+        return { value: subsequence, done: false };
+      }
+      var tmp, j;
+      i--;
+      if (i < 0)
+        return { done: true };
+      cycles[i]--;
+      if (cycles[i] === 0) {
+        tmp = indices[i];
+        for (j = i;j < n - 1; j++)
+          indices[j] = indices[j + 1];
+        indices[n - 1] = tmp;
+        cycles[i] = n - i;
+        return next();
+      } else {
+        j = cycles[i];
+        tmp = indices[i];
+        indices[i] = indices[n - j];
+        indices[n - j] = tmp;
+        i = r;
+        indicesToItems(subsequence, array, indices, r);
+        return { value: subsequence, done: false };
+      }
+    });
+  };
+});
+
+// node_modules/obliterator/power-set.js
+var require_power_set = __commonJS((exports, module) => {
+  var Iterator = require_iterator();
+  var combinations = require_combinations();
+  var chain = require_chain();
+  module.exports = function powerSet(array) {
+    var n = array.length;
+    var iterators = new Array(n + 1);
+    iterators[0] = Iterator.of([]);
+    for (var i = 1;i < n + 1; i++)
+      iterators[i] = combinations(array, i);
+    return chain.apply(null, iterators);
+  };
+});
+
+// node_modules/obliterator/range.js
+var require_range = __commonJS((exports, module) => {
+  var Iterator = require_iterator();
+  module.exports = function range(start, end, step) {
+    if (arguments.length === 1) {
+      end = start;
+      start = 0;
+    }
+    if (arguments.length < 3)
+      step = 1;
+    var i = start;
+    var iterator = new Iterator(function() {
+      if (i < end) {
+        var value = i;
+        i += step;
+        return { value, done: false };
+      }
+      return { done: true };
+    });
+    iterator.start = start;
+    iterator.end = end;
+    iterator.step = step;
+    return iterator;
+  };
+});
+
+// node_modules/obliterator/some.js
+var require_some = __commonJS((exports, module) => {
+  var iter = require_iter();
+  module.exports = function some(iterable, predicate) {
+    var iterator = iter(iterable);
+    var step;
+    while (step = iterator.next(), !step.done) {
+      if (predicate(step.value))
+        return true;
+    }
+    return false;
+  };
+});
+
+// node_modules/obliterator/split.js
+var require_split = __commonJS((exports, module) => {
+  var Iterator = require_iterator();
+  function makeGlobal(pattern) {
+    var flags = "g";
+    if (pattern.multiline)
+      flags += "m";
+    if (pattern.ignoreCase)
+      flags += "i";
+    if (pattern.sticky)
+      flags += "y";
+    if (pattern.unicode)
+      flags += "u";
+    return new RegExp(pattern.source, flags);
+  }
+  module.exports = function split(pattern, string) {
+    if (!(pattern instanceof RegExp))
+      throw new Error("obliterator/split: invalid pattern. Expecting a regular expression.");
+    if (typeof string !== "string")
+      throw new Error("obliterator/split: invalid target. Expecting a string.");
+    pattern = makeGlobal(pattern);
+    var consumed = false, current = 0;
+    return new Iterator(function() {
+      if (consumed)
+        return { done: true };
+      var match = pattern.exec(string), value, length;
+      if (match) {
+        length = match.index + match[0].length;
+        value = string.slice(current, match.index);
+        current = length;
+      } else {
+        consumed = true;
+        value = string.slice(current);
+      }
+      return { value, done: false };
+    });
+  };
+});
+
+// node_modules/obliterator/take.js
+var require_take = __commonJS((exports, module) => {
+  var iter = require_iter();
+  module.exports = function take(iterable, n) {
+    var l = arguments.length > 1 ? n : Infinity, array = l !== Infinity ? new Array(l) : [], step, i = 0;
+    var iterator = iter(iterable);
+    while (true) {
+      if (i === l)
+        return array;
+      step = iterator.next();
+      if (step.done) {
+        if (i !== n)
+          array.length = i;
+        return array;
+      }
+      array[i++] = step.value;
+    }
+  };
+});
+
+// node_modules/obliterator/take-into.js
+var require_take_into = __commonJS((exports, module) => {
+  var iter = require_iter();
+  module.exports = function takeInto(ArrayClass, iterable, n) {
+    var array = new ArrayClass(n), step, i = 0;
+    var iterator = iter(iterable);
+    while (true) {
+      if (i === n)
+        return array;
+      step = iterator.next();
+      if (step.done) {
+        if (i !== n)
+          return array.slice(0, i);
+        return array;
+      }
+      array[i++] = step.value;
+    }
+  };
+});
+
+// node_modules/source-map-js/lib/base64.js
+var require_base64 = __commonJS((exports) => {
+  var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+  exports.encode = function(number) {
+    if (0 <= number && number < intToCharMap.length) {
+      return intToCharMap[number];
+    }
+    throw new TypeError("Must be between 0 and 63: " + number);
+  };
+  exports.decode = function(charCode) {
+    var bigA = 65;
+    var bigZ = 90;
+    var littleA = 97;
+    var littleZ = 122;
+    var zero = 48;
+    var nine = 57;
+    var plus = 43;
+    var slash = 47;
+    var littleOffset = 26;
+    var numberOffset = 52;
+    if (bigA <= charCode && charCode <= bigZ) {
+      return charCode - bigA;
+    }
+    if (littleA <= charCode && charCode <= littleZ) {
+      return charCode - littleA + littleOffset;
+    }
+    if (zero <= charCode && charCode <= nine) {
+      return charCode - zero + numberOffset;
+    }
+    if (charCode == plus) {
+      return 62;
+    }
+    if (charCode == slash) {
+      return 63;
+    }
+    return -1;
+  };
+});
+
+// node_modules/source-map-js/lib/base64-vlq.js
+var require_base64_vlq = __commonJS((exports) => {
+  var base64 = require_base64();
+  var VLQ_BASE_SHIFT = 5;
+  var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+  var VLQ_BASE_MASK = VLQ_BASE - 1;
+  var VLQ_CONTINUATION_BIT = VLQ_BASE;
+  function toVLQSigned(aValue) {
+    return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
+  }
+  function fromVLQSigned(aValue) {
+    var isNegative = (aValue & 1) === 1;
+    var shifted = aValue >> 1;
+    return isNegative ? -shifted : shifted;
+  }
+  exports.encode = function base64VLQ_encode(aValue) {
+    var encoded = "";
+    var digit;
+    var vlq = toVLQSigned(aValue);
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64.encode(digit);
+    } while (vlq > 0);
+    return encoded;
+  };
+  exports.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
+    var strLen = aStr.length;
+    var result = 0;
+    var shift = 0;
+    var continuation, digit;
+    do {
+      if (aIndex >= strLen) {
+        throw new Error("Expected more digits in base 64 VLQ value.");
+      }
+      digit = base64.decode(aStr.charCodeAt(aIndex++));
+      if (digit === -1) {
+        throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
+      }
+      continuation = !!(digit & VLQ_CONTINUATION_BIT);
+      digit &= VLQ_BASE_MASK;
+      result = result + (digit << shift);
+      shift += VLQ_BASE_SHIFT;
+    } while (continuation);
+    aOutParam.value = fromVLQSigned(result);
+    aOutParam.rest = aIndex;
+  };
+});
+
+// node_modules/source-map-js/lib/util.js
+var require_util = __commonJS((exports) => {
+  function getArg(aArgs, aName, aDefaultValue) {
+    if (aName in aArgs) {
+      return aArgs[aName];
+    } else if (arguments.length === 3) {
+      return aDefaultValue;
+    } else {
+      throw new Error('"' + aName + '" is a required argument.');
+    }
+  }
+  exports.getArg = getArg;
+  var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+  var dataUrlRegexp = /^data:.+\,.+$/;
+  function urlParse(aUrl) {
+    var match = aUrl.match(urlRegexp);
+    if (!match) {
+      return null;
+    }
+    return {
+      scheme: match[1],
+      auth: match[2],
+      host: match[3],
+      port: match[4],
+      path: match[5]
+    };
+  }
+  exports.urlParse = urlParse;
+  function urlGenerate(aParsedUrl) {
+    var url = "";
+    if (aParsedUrl.scheme) {
+      url += aParsedUrl.scheme + ":";
+    }
+    url += "//";
+    if (aParsedUrl.auth) {
+      url += aParsedUrl.auth + "@";
+    }
+    if (aParsedUrl.host) {
+      url += aParsedUrl.host;
+    }
+    if (aParsedUrl.port) {
+      url += ":" + aParsedUrl.port;
+    }
+    if (aParsedUrl.path) {
+      url += aParsedUrl.path;
+    }
+    return url;
+  }
+  exports.urlGenerate = urlGenerate;
+  var MAX_CACHED_INPUTS = 32;
+  function lruMemoize(f) {
+    var cache = [];
+    return function(input) {
+      for (var i = 0;i < cache.length; i++) {
+        if (cache[i].input === input) {
+          var temp = cache[0];
+          cache[0] = cache[i];
+          cache[i] = temp;
+          return cache[0].result;
+        }
+      }
+      var result = f(input);
+      cache.unshift({
+        input,
+        result
+      });
+      if (cache.length > MAX_CACHED_INPUTS) {
+        cache.pop();
+      }
+      return result;
+    };
+  }
+  var normalize = lruMemoize(function normalize2(aPath) {
+    var path3 = aPath;
+    var url = urlParse(aPath);
+    if (url) {
+      if (!url.path) {
+        return aPath;
+      }
+      path3 = url.path;
+    }
+    var isAbsolute = exports.isAbsolute(path3);
+    var parts = [];
+    var start = 0;
+    var i = 0;
+    while (true) {
+      start = i;
+      i = path3.indexOf("/", start);
+      if (i === -1) {
+        parts.push(path3.slice(start));
+        break;
+      } else {
+        parts.push(path3.slice(start, i));
+        while (i < path3.length && path3[i] === "/") {
+          i++;
+        }
+      }
+    }
+    for (var part, up = 0, i = parts.length - 1;i >= 0; i--) {
+      part = parts[i];
+      if (part === ".") {
+        parts.splice(i, 1);
+      } else if (part === "..") {
+        up++;
+      } else if (up > 0) {
+        if (part === "") {
+          parts.splice(i + 1, up);
+          up = 0;
+        } else {
+          parts.splice(i, 2);
+          up--;
+        }
+      }
+    }
+    path3 = parts.join("/");
+    if (path3 === "") {
+      path3 = isAbsolute ? "/" : ".";
+    }
+    if (url) {
+      url.path = path3;
+      return urlGenerate(url);
+    }
+    return path3;
+  });
+  exports.normalize = normalize;
+  function join(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+    if (aPath === "") {
+      aPath = ".";
+    }
+    var aPathUrl = urlParse(aPath);
+    var aRootUrl = urlParse(aRoot);
+    if (aRootUrl) {
+      aRoot = aRootUrl.path || "/";
+    }
+    if (aPathUrl && !aPathUrl.scheme) {
+      if (aRootUrl) {
+        aPathUrl.scheme = aRootUrl.scheme;
+      }
+      return urlGenerate(aPathUrl);
+    }
+    if (aPathUrl || aPath.match(dataUrlRegexp)) {
+      return aPath;
+    }
+    if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+      aRootUrl.host = aPath;
+      return urlGenerate(aRootUrl);
+    }
+    var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
+    if (aRootUrl) {
+      aRootUrl.path = joined;
+      return urlGenerate(aRootUrl);
+    }
+    return joined;
+  }
+  exports.join = join;
+  exports.isAbsolute = function(aPath) {
+    return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
+  };
+  function relative(aRoot, aPath) {
+    if (aRoot === "") {
+      aRoot = ".";
+    }
+    aRoot = aRoot.replace(/\/$/, "");
+    var level = 0;
+    while (aPath.indexOf(aRoot + "/") !== 0) {
+      var index = aRoot.lastIndexOf("/");
+      if (index < 0) {
+        return aPath;
+      }
+      aRoot = aRoot.slice(0, index);
+      if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+        return aPath;
+      }
+      ++level;
+    }
+    return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
+  }
+  exports.relative = relative;
+  var supportsNullProto = function() {
+    var obj = Object.create(null);
+    return !("__proto__" in obj);
+  }();
+  function identity(s) {
+    return s;
+  }
+  function toSetString(aStr) {
+    if (isProtoString(aStr)) {
+      return "$" + aStr;
+    }
+    return aStr;
+  }
+  exports.toSetString = supportsNullProto ? identity : toSetString;
+  function fromSetString(aStr) {
+    if (isProtoString(aStr)) {
+      return aStr.slice(1);
+    }
+    return aStr;
+  }
+  exports.fromSetString = supportsNullProto ? identity : fromSetString;
+  function isProtoString(s) {
+    if (!s) {
+      return false;
+    }
+    var length = s.length;
+    if (length < 9) {
+      return false;
+    }
+    if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
+      return false;
+    }
+    for (var i = length - 10;i >= 0; i--) {
+      if (s.charCodeAt(i) !== 36) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+    var cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0 || onlyCompareOriginal) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByOriginalPositions = compareByOriginalPositions;
+  function compareByOriginalPositionsNoSource(mappingA, mappingB, onlyCompareOriginal) {
+    var cmp;
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0 || onlyCompareOriginal) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByOriginalPositionsNoSource = compareByOriginalPositionsNoSource;
+  function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
+    var cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0 || onlyCompareGenerated) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
+  function compareByGeneratedPositionsDeflatedNoLine(mappingA, mappingB, onlyCompareGenerated) {
+    var cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0 || onlyCompareGenerated) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsDeflatedNoLine = compareByGeneratedPositionsDeflatedNoLine;
+  function strcmp(aStr1, aStr2) {
+    if (aStr1 === aStr2) {
+      return 0;
+    }
+    if (aStr1 === null) {
+      return 1;
+    }
+    if (aStr2 === null) {
+      return -1;
+    }
+    if (aStr1 > aStr2) {
+      return 1;
+    }
+    return -1;
+  }
+  function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+    var cmp = mappingA.generatedLine - mappingB.generatedLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = strcmp(mappingA.source, mappingB.source);
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalLine - mappingB.originalLine;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    cmp = mappingA.originalColumn - mappingB.originalColumn;
+    if (cmp !== 0) {
+      return cmp;
+    }
+    return strcmp(mappingA.name, mappingB.name);
+  }
+  exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+  function parseSourceMapInput(str) {
+    return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+  }
+  exports.parseSourceMapInput = parseSourceMapInput;
+  function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+    sourceURL = sourceURL || "";
+    if (sourceRoot) {
+      if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
+        sourceRoot += "/";
+      }
+      sourceURL = sourceRoot + sourceURL;
+    }
+    if (sourceMapURL) {
+      var parsed = urlParse(sourceMapURL);
+      if (!parsed) {
+        throw new Error("sourceMapURL could not be parsed");
+      }
+      if (parsed.path) {
+        var index = parsed.path.lastIndexOf("/");
+        if (index >= 0) {
+          parsed.path = parsed.path.substring(0, index + 1);
+        }
+      }
+      sourceURL = join(urlGenerate(parsed), sourceURL);
+    }
+    return normalize(sourceURL);
+  }
+  exports.computeSourceURL = computeSourceURL;
+});
+
+// node_modules/source-map-js/lib/array-set.js
+var require_array_set = __commonJS((exports) => {
+  var util = require_util();
+  var has = Object.prototype.hasOwnProperty;
+  var hasNativeMap = typeof Map !== "undefined";
+  function ArraySet() {
+    this._array = [];
+    this._set = hasNativeMap ? new Map : Object.create(null);
+  }
+  ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
+    var set = new ArraySet;
+    for (var i = 0, len = aArray.length;i < len; i++) {
+      set.add(aArray[i], aAllowDuplicates);
+    }
+    return set;
+  };
+  ArraySet.prototype.size = function ArraySet_size() {
+    return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
+  };
+  ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
+    var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
+    var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
+    var idx = this._array.length;
+    if (!isDuplicate || aAllowDuplicates) {
+      this._array.push(aStr);
+    }
+    if (!isDuplicate) {
+      if (hasNativeMap) {
+        this._set.set(aStr, idx);
+      } else {
+        this._set[sStr] = idx;
+      }
+    }
+  };
+  ArraySet.prototype.has = function ArraySet_has(aStr) {
+    if (hasNativeMap) {
+      return this._set.has(aStr);
+    } else {
+      var sStr = util.toSetString(aStr);
+      return has.call(this._set, sStr);
+    }
+  };
+  ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
+    if (hasNativeMap) {
+      var idx = this._set.get(aStr);
+      if (idx >= 0) {
+        return idx;
+      }
+    } else {
+      var sStr = util.toSetString(aStr);
+      if (has.call(this._set, sStr)) {
+        return this._set[sStr];
+      }
+    }
+    throw new Error('"' + aStr + '" is not in the set.');
+  };
+  ArraySet.prototype.at = function ArraySet_at(aIdx) {
+    if (aIdx >= 0 && aIdx < this._array.length) {
+      return this._array[aIdx];
+    }
+    throw new Error("No element indexed by " + aIdx);
+  };
+  ArraySet.prototype.toArray = function ArraySet_toArray() {
+    return this._array.slice();
+  };
+  exports.ArraySet = ArraySet;
+});
+
+// node_modules/source-map-js/lib/mapping-list.js
+var require_mapping_list = __commonJS((exports) => {
+  var util = require_util();
+  function generatedPositionAfter(mappingA, mappingB) {
+    var lineA = mappingA.generatedLine;
+    var lineB = mappingB.generatedLine;
+    var columnA = mappingA.generatedColumn;
+    var columnB = mappingB.generatedColumn;
+    return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
+  }
+  function MappingList() {
+    this._array = [];
+    this._sorted = true;
+    this._last = { generatedLine: -1, generatedColumn: 0 };
+  }
+  MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
+    this._array.forEach(aCallback, aThisArg);
+  };
+  MappingList.prototype.add = function MappingList_add(aMapping) {
+    if (generatedPositionAfter(this._last, aMapping)) {
+      this._last = aMapping;
+      this._array.push(aMapping);
+    } else {
+      this._sorted = false;
+      this._array.push(aMapping);
+    }
+  };
+  MappingList.prototype.toArray = function MappingList_toArray() {
+    if (!this._sorted) {
+      this._array.sort(util.compareByGeneratedPositionsInflated);
+      this._sorted = true;
+    }
+    return this._array;
+  };
+  exports.MappingList = MappingList;
+});
+
+// node_modules/source-map-js/lib/source-map-generator.js
+var require_source_map_generator = __commonJS((exports) => {
+  var base64VLQ = require_base64_vlq();
+  var util = require_util();
+  var ArraySet = require_array_set().ArraySet;
+  var MappingList = require_mapping_list().MappingList;
+  function SourceMapGenerator(aArgs) {
+    if (!aArgs) {
+      aArgs = {};
+    }
+    this._file = util.getArg(aArgs, "file", null);
+    this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
+    this._skipValidation = util.getArg(aArgs, "skipValidation", false);
+    this._ignoreInvalidMapping = util.getArg(aArgs, "ignoreInvalidMapping", false);
+    this._sources = new ArraySet;
+    this._names = new ArraySet;
+    this._mappings = new MappingList;
+    this._sourcesContents = null;
+  }
+  SourceMapGenerator.prototype._version = 3;
+  SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer, generatorOps) {
+    var sourceRoot = aSourceMapConsumer.sourceRoot;
+    var generator = new SourceMapGenerator(Object.assign(generatorOps || {}, {
+      file: aSourceMapConsumer.file,
+      sourceRoot
+    }));
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      var newMapping = {
+        generated: {
+          line: mapping.generatedLine,
+          column: mapping.generatedColumn
+        }
+      };
+      if (mapping.source != null) {
+        newMapping.source = mapping.source;
+        if (sourceRoot != null) {
+          newMapping.source = util.relative(sourceRoot, newMapping.source);
+        }
+        newMapping.original = {
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        };
+        if (mapping.name != null) {
+          newMapping.name = mapping.name;
+        }
+      }
+      generator.addMapping(newMapping);
+    });
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var sourceRelative = sourceFile;
+      if (sourceRoot !== null) {
+        sourceRelative = util.relative(sourceRoot, sourceFile);
+      }
+      if (!generator._sources.has(sourceRelative)) {
+        generator._sources.add(sourceRelative);
+      }
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        generator.setSourceContent(sourceFile, content);
+      }
+    });
+    return generator;
+  };
+  SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
+    var generated = util.getArg(aArgs, "generated");
+    var original = util.getArg(aArgs, "original", null);
+    var source = util.getArg(aArgs, "source", null);
+    var name = util.getArg(aArgs, "name", null);
+    if (!this._skipValidation) {
+      if (this._validateMapping(generated, original, source, name) === false) {
+        return;
+      }
+    }
+    if (source != null) {
+      source = String(source);
+      if (!this._sources.has(source)) {
+        this._sources.add(source);
+      }
+    }
+    if (name != null) {
+      name = String(name);
+      if (!this._names.has(name)) {
+        this._names.add(name);
+      }
+    }
+    this._mappings.add({
+      generatedLine: generated.line,
+      generatedColumn: generated.column,
+      originalLine: original != null && original.line,
+      originalColumn: original != null && original.column,
+      source,
+      name
+    });
+  };
+  SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
+    var source = aSourceFile;
+    if (this._sourceRoot != null) {
+      source = util.relative(this._sourceRoot, source);
+    }
+    if (aSourceContent != null) {
+      if (!this._sourcesContents) {
+        this._sourcesContents = Object.create(null);
+      }
+      this._sourcesContents[util.toSetString(source)] = aSourceContent;
+    } else if (this._sourcesContents) {
+      delete this._sourcesContents[util.toSetString(source)];
+      if (Object.keys(this._sourcesContents).length === 0) {
+        this._sourcesContents = null;
+      }
+    }
+  };
+  SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
+    var sourceFile = aSourceFile;
+    if (aSourceFile == null) {
+      if (aSourceMapConsumer.file == null) {
+        throw new Error("SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " + `or the source map's "file" property. Both were omitted.`);
+      }
+      sourceFile = aSourceMapConsumer.file;
+    }
+    var sourceRoot = this._sourceRoot;
+    if (sourceRoot != null) {
+      sourceFile = util.relative(sourceRoot, sourceFile);
+    }
+    var newSources = new ArraySet;
+    var newNames = new ArraySet;
+    this._mappings.unsortedForEach(function(mapping) {
+      if (mapping.source === sourceFile && mapping.originalLine != null) {
+        var original = aSourceMapConsumer.originalPositionFor({
+          line: mapping.originalLine,
+          column: mapping.originalColumn
+        });
+        if (original.source != null) {
+          mapping.source = original.source;
+          if (aSourceMapPath != null) {
+            mapping.source = util.join(aSourceMapPath, mapping.source);
+          }
+          if (sourceRoot != null) {
+            mapping.source = util.relative(sourceRoot, mapping.source);
+          }
+          mapping.originalLine = original.line;
+          mapping.originalColumn = original.column;
+          if (original.name != null) {
+            mapping.name = original.name;
+          }
+        }
+      }
+      var source = mapping.source;
+      if (source != null && !newSources.has(source)) {
+        newSources.add(source);
+      }
+      var name = mapping.name;
+      if (name != null && !newNames.has(name)) {
+        newNames.add(name);
+      }
+    }, this);
+    this._sources = newSources;
+    this._names = newNames;
+    aSourceMapConsumer.sources.forEach(function(sourceFile2) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
+      if (content != null) {
+        if (aSourceMapPath != null) {
+          sourceFile2 = util.join(aSourceMapPath, sourceFile2);
+        }
+        if (sourceRoot != null) {
+          sourceFile2 = util.relative(sourceRoot, sourceFile2);
+        }
+        this.setSourceContent(sourceFile2, content);
+      }
+    }, this);
+  };
+  SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
+    if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
+      var message = "original.line and original.column are not numbers -- you probably meant to omit " + "the original mapping entirely and only map the generated position. If so, pass " + "null for the original mapping instead of an object with empty or null values.";
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+    if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
+      return;
+    } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
+      return;
+    } else {
+      var message = "Invalid mapping: " + JSON.stringify({
+        generated: aGenerated,
+        source: aSource,
+        original: aOriginal,
+        name: aName
+      });
+      if (this._ignoreInvalidMapping) {
+        if (typeof console !== "undefined" && console.warn) {
+          console.warn(message);
+        }
+        return false;
+      } else {
+        throw new Error(message);
+      }
+    }
+  };
+  SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
+    var previousGeneratedColumn = 0;
+    var previousGeneratedLine = 1;
+    var previousOriginalColumn = 0;
+    var previousOriginalLine = 0;
+    var previousName = 0;
+    var previousSource = 0;
+    var result = "";
+    var next;
+    var mapping;
+    var nameIdx;
+    var sourceIdx;
+    var mappings = this._mappings.toArray();
+    for (var i = 0, len = mappings.length;i < len; i++) {
+      mapping = mappings[i];
+      next = "";
+      if (mapping.generatedLine !== previousGeneratedLine) {
+        previousGeneratedColumn = 0;
+        while (mapping.generatedLine !== previousGeneratedLine) {
+          next += ";";
+          previousGeneratedLine++;
+        }
+      } else {
+        if (i > 0) {
+          if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
+            continue;
+          }
+          next += ",";
+        }
+      }
+      next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
+      previousGeneratedColumn = mapping.generatedColumn;
+      if (mapping.source != null) {
+        sourceIdx = this._sources.indexOf(mapping.source);
+        next += base64VLQ.encode(sourceIdx - previousSource);
+        previousSource = sourceIdx;
+        next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
+        previousOriginalLine = mapping.originalLine - 1;
+        next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
+        previousOriginalColumn = mapping.originalColumn;
+        if (mapping.name != null) {
+          nameIdx = this._names.indexOf(mapping.name);
+          next += base64VLQ.encode(nameIdx - previousName);
+          previousName = nameIdx;
+        }
+      }
+      result += next;
+    }
+    return result;
+  };
+  SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
+    return aSources.map(function(source) {
+      if (!this._sourcesContents) {
+        return null;
+      }
+      if (aSourceRoot != null) {
+        source = util.relative(aSourceRoot, source);
+      }
+      var key = util.toSetString(source);
+      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
+    }, this);
+  };
+  SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
+    var map = {
+      version: this._version,
+      sources: this._sources.toArray(),
+      names: this._names.toArray(),
+      mappings: this._serializeMappings()
+    };
+    if (this._file != null) {
+      map.file = this._file;
+    }
+    if (this._sourceRoot != null) {
+      map.sourceRoot = this._sourceRoot;
+    }
+    if (this._sourcesContents) {
+      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
+    }
+    return map;
+  };
+  SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
+    return JSON.stringify(this.toJSON());
+  };
+  exports.SourceMapGenerator = SourceMapGenerator;
+});
+
+// node_modules/source-map-js/lib/binary-search.js
+var require_binary_search = __commonJS((exports) => {
+  exports.GREATEST_LOWER_BOUND = 1;
+  exports.LEAST_UPPER_BOUND = 2;
+  function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+    var mid = Math.floor((aHigh - aLow) / 2) + aLow;
+    var cmp = aCompare(aNeedle, aHaystack[mid], true);
+    if (cmp === 0) {
+      return mid;
+    } else if (cmp > 0) {
+      if (aHigh - mid > 1) {
+        return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
+      }
+      if (aBias == exports.LEAST_UPPER_BOUND) {
+        return aHigh < aHaystack.length ? aHigh : -1;
+      } else {
+        return mid;
+      }
+    } else {
+      if (mid - aLow > 1) {
+        return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
+      }
+      if (aBias == exports.LEAST_UPPER_BOUND) {
+        return mid;
+      } else {
+        return aLow < 0 ? -1 : aLow;
+      }
+    }
+  }
+  exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+    if (aHaystack.length === 0) {
+      return -1;
+    }
+    var index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack, aCompare, aBias || exports.GREATEST_LOWER_BOUND);
+    if (index < 0) {
+      return -1;
+    }
+    while (index - 1 >= 0) {
+      if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+        break;
+      }
+      --index;
+    }
+    return index;
+  };
+});
+
+// node_modules/source-map-js/lib/quick-sort.js
+var require_quick_sort = __commonJS((exports) => {
+  function SortTemplate(comparator) {
+    function swap(ary, x, y) {
+      var temp = ary[x];
+      ary[x] = ary[y];
+      ary[y] = temp;
+    }
+    function randomIntInRange(low, high) {
+      return Math.round(low + Math.random() * (high - low));
+    }
+    function doQuickSort(ary, comparator2, p, r) {
+      if (p < r) {
+        var pivotIndex = randomIntInRange(p, r);
+        var i = p - 1;
+        swap(ary, pivotIndex, r);
+        var pivot = ary[r];
+        for (var j = p;j < r; j++) {
+          if (comparator2(ary[j], pivot, false) <= 0) {
+            i += 1;
+            swap(ary, i, j);
+          }
+        }
+        swap(ary, i + 1, j);
+        var q = i + 1;
+        doQuickSort(ary, comparator2, p, q - 1);
+        doQuickSort(ary, comparator2, q + 1, r);
+      }
+    }
+    return doQuickSort;
+  }
+  function cloneSort(comparator) {
+    let template = SortTemplate.toString();
+    let templateFn = new Function(`return ${template}`)();
+    return templateFn(comparator);
+  }
+  var sortCache = new WeakMap;
+  exports.quickSort = function(ary, comparator, start = 0) {
+    let doQuickSort = sortCache.get(comparator);
+    if (doQuickSort === undefined) {
+      doQuickSort = cloneSort(comparator);
+      sortCache.set(comparator, doQuickSort);
+    }
+    doQuickSort(ary, comparator, start, ary.length - 1);
+  };
+});
+
+// node_modules/source-map-js/lib/source-map-consumer.js
+var require_source_map_consumer = __commonJS((exports) => {
+  var util = require_util();
+  var binarySearch = require_binary_search();
+  var ArraySet = require_array_set().ArraySet;
+  var base64VLQ = require_base64_vlq();
+  var quickSort = require_quick_sort().quickSort;
+  function SourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
+  }
+  SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
+    return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+  };
+  SourceMapConsumer.prototype._version = 3;
+  SourceMapConsumer.prototype.__generatedMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      if (!this.__generatedMappings) {
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+      return this.__generatedMappings;
+    }
+  });
+  SourceMapConsumer.prototype.__originalMappings = null;
+  Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
+    configurable: true,
+    enumerable: true,
+    get: function() {
+      if (!this.__originalMappings) {
+        this._parseMappings(this._mappings, this.sourceRoot);
+      }
+      return this.__originalMappings;
+    }
+  });
+  SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
+    var c = aStr.charAt(index);
+    return c === ";" || c === ",";
+  };
+  SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    throw new Error("Subclasses must implement _parseMappings");
+  };
+  SourceMapConsumer.GENERATED_ORDER = 1;
+  SourceMapConsumer.ORIGINAL_ORDER = 2;
+  SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
+  SourceMapConsumer.LEAST_UPPER_BOUND = 2;
+  SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
+    var context = aContext || null;
+    var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
+    var mappings;
+    switch (order) {
+      case SourceMapConsumer.GENERATED_ORDER:
+        mappings = this._generatedMappings;
+        break;
+      case SourceMapConsumer.ORIGINAL_ORDER:
+        mappings = this._originalMappings;
+        break;
+      default:
+        throw new Error("Unknown order of iteration.");
+    }
+    var sourceRoot = this.sourceRoot;
+    var boundCallback = aCallback.bind(context);
+    var names = this._names;
+    var sources = this._sources;
+    var sourceMapURL = this._sourceMapURL;
+    for (var i = 0, n = mappings.length;i < n; i++) {
+      var mapping = mappings[i];
+      var source = mapping.source === null ? null : sources.at(mapping.source);
+      if (source !== null) {
+        source = util.computeSourceURL(sourceRoot, source, sourceMapURL);
+      }
+      boundCallback({
+        source,
+        generatedLine: mapping.generatedLine,
+        generatedColumn: mapping.generatedColumn,
+        originalLine: mapping.originalLine,
+        originalColumn: mapping.originalColumn,
+        name: mapping.name === null ? null : names.at(mapping.name)
+      });
+    }
+  };
+  SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
+    var line = util.getArg(aArgs, "line");
+    var needle = {
+      source: util.getArg(aArgs, "source"),
+      originalLine: line,
+      originalColumn: util.getArg(aArgs, "column", 0)
+    };
+    needle.source = this._findSourceIndex(needle.source);
+    if (needle.source < 0) {
+      return [];
+    }
+    var mappings = [];
+    var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, binarySearch.LEAST_UPPER_BOUND);
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+      if (aArgs.column === undefined) {
+        var originalLine = mapping.originalLine;
+        while (mapping && mapping.originalLine === originalLine) {
+          mappings.push({
+            line: util.getArg(mapping, "generatedLine", null),
+            column: util.getArg(mapping, "generatedColumn", null),
+            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      } else {
+        var originalColumn = mapping.originalColumn;
+        while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
+          mappings.push({
+            line: util.getArg(mapping, "generatedLine", null),
+            column: util.getArg(mapping, "generatedColumn", null),
+            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+          });
+          mapping = this._originalMappings[++index];
+        }
+      }
+    }
+    return mappings;
+  };
+  exports.SourceMapConsumer = SourceMapConsumer;
+  function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    var version = util.getArg(sourceMap, "version");
+    var sources = util.getArg(sourceMap, "sources");
+    var names = util.getArg(sourceMap, "names", []);
+    var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
+    var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
+    var mappings = util.getArg(sourceMap, "mappings");
+    var file = util.getArg(sourceMap, "file", null);
+    if (version != this._version) {
+      throw new Error("Unsupported version: " + version);
+    }
+    if (sourceRoot) {
+      sourceRoot = util.normalize(sourceRoot);
+    }
+    sources = sources.map(String).map(util.normalize).map(function(source) {
+      return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
+    });
+    this._names = ArraySet.fromArray(names.map(String), true);
+    this._sources = ArraySet.fromArray(sources, true);
+    this._absoluteSources = this._sources.toArray().map(function(s) {
+      return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+    });
+    this.sourceRoot = sourceRoot;
+    this.sourcesContent = sourcesContent;
+    this._mappings = mappings;
+    this._sourceMapURL = aSourceMapURL;
+    this.file = file;
+  }
+  BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+  BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
+  BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+    if (this._sources.has(relativeSource)) {
+      return this._sources.indexOf(relativeSource);
+    }
+    var i;
+    for (i = 0;i < this._absoluteSources.length; ++i) {
+      if (this._absoluteSources[i] == aSource) {
+        return i;
+      }
+    }
+    return -1;
+  };
+  BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
+    var smc = Object.create(BasicSourceMapConsumer.prototype);
+    var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
+    var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
+    smc.sourceRoot = aSourceMap._sourceRoot;
+    smc.sourcesContent = aSourceMap._generateSourcesContent(smc._sources.toArray(), smc.sourceRoot);
+    smc.file = aSourceMap._file;
+    smc._sourceMapURL = aSourceMapURL;
+    smc._absoluteSources = smc._sources.toArray().map(function(s) {
+      return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
+    });
+    var generatedMappings = aSourceMap._mappings.toArray().slice();
+    var destGeneratedMappings = smc.__generatedMappings = [];
+    var destOriginalMappings = smc.__originalMappings = [];
+    for (var i = 0, length = generatedMappings.length;i < length; i++) {
+      var srcMapping = generatedMappings[i];
+      var destMapping = new Mapping;
+      destMapping.generatedLine = srcMapping.generatedLine;
+      destMapping.generatedColumn = srcMapping.generatedColumn;
+      if (srcMapping.source) {
+        destMapping.source = sources.indexOf(srcMapping.source);
+        destMapping.originalLine = srcMapping.originalLine;
+        destMapping.originalColumn = srcMapping.originalColumn;
+        if (srcMapping.name) {
+          destMapping.name = names.indexOf(srcMapping.name);
+        }
+        destOriginalMappings.push(destMapping);
+      }
+      destGeneratedMappings.push(destMapping);
+    }
+    quickSort(smc.__originalMappings, util.compareByOriginalPositions);
+    return smc;
+  };
+  BasicSourceMapConsumer.prototype._version = 3;
+  Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
+    get: function() {
+      return this._absoluteSources.slice();
+    }
+  });
+  function Mapping() {
+    this.generatedLine = 0;
+    this.generatedColumn = 0;
+    this.source = null;
+    this.originalLine = null;
+    this.originalColumn = null;
+    this.name = null;
+  }
+  var compareGenerated = util.compareByGeneratedPositionsDeflatedNoLine;
+  function sortGenerated(array, start) {
+    let l = array.length;
+    let n = array.length - start;
+    if (n <= 1) {
+      return;
+    } else if (n == 2) {
+      let a = array[start];
+      let b = array[start + 1];
+      if (compareGenerated(a, b) > 0) {
+        array[start] = b;
+        array[start + 1] = a;
+      }
+    } else if (n < 20) {
+      for (let i = start;i < l; i++) {
+        for (let j = i;j > start; j--) {
+          let a = array[j - 1];
+          let b = array[j];
+          if (compareGenerated(a, b) <= 0) {
+            break;
+          }
+          array[j - 1] = b;
+          array[j] = a;
+        }
+      }
+    } else {
+      quickSort(array, compareGenerated, start);
+    }
+  }
+  BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    var generatedLine = 1;
+    var previousGeneratedColumn = 0;
+    var previousOriginalLine = 0;
+    var previousOriginalColumn = 0;
+    var previousSource = 0;
+    var previousName = 0;
+    var length = aStr.length;
+    var index = 0;
+    var cachedSegments = {};
+    var temp = {};
+    var originalMappings = [];
+    var generatedMappings = [];
+    var mapping, str, segment, end, value;
+    let subarrayStart = 0;
+    while (index < length) {
+      if (aStr.charAt(index) === ";") {
+        generatedLine++;
+        index++;
+        previousGeneratedColumn = 0;
+        sortGenerated(generatedMappings, subarrayStart);
+        subarrayStart = generatedMappings.length;
+      } else if (aStr.charAt(index) === ",") {
+        index++;
+      } else {
+        mapping = new Mapping;
+        mapping.generatedLine = generatedLine;
+        for (end = index;end < length; end++) {
+          if (this._charIsMappingSeparator(aStr, end)) {
+            break;
+          }
+        }
+        str = aStr.slice(index, end);
+        segment = [];
+        while (index < end) {
+          base64VLQ.decode(aStr, index, temp);
+          value = temp.value;
+          index = temp.rest;
+          segment.push(value);
+        }
+        if (segment.length === 2) {
+          throw new Error("Found a source, but no line and column");
+        }
+        if (segment.length === 3) {
+          throw new Error("Found a source and line, but no column");
+        }
+        mapping.generatedColumn = previousGeneratedColumn + segment[0];
+        previousGeneratedColumn = mapping.generatedColumn;
+        if (segment.length > 1) {
+          mapping.source = previousSource + segment[1];
+          previousSource += segment[1];
+          mapping.originalLine = previousOriginalLine + segment[2];
+          previousOriginalLine = mapping.originalLine;
+          mapping.originalLine += 1;
+          mapping.originalColumn = previousOriginalColumn + segment[3];
+          previousOriginalColumn = mapping.originalColumn;
+          if (segment.length > 4) {
+            mapping.name = previousName + segment[4];
+            previousName += segment[4];
+          }
+        }
+        generatedMappings.push(mapping);
+        if (typeof mapping.originalLine === "number") {
+          let currentSource = mapping.source;
+          while (originalMappings.length <= currentSource) {
+            originalMappings.push(null);
+          }
+          if (originalMappings[currentSource] === null) {
+            originalMappings[currentSource] = [];
+          }
+          originalMappings[currentSource].push(mapping);
+        }
+      }
+    }
+    sortGenerated(generatedMappings, subarrayStart);
+    this.__generatedMappings = generatedMappings;
+    for (var i = 0;i < originalMappings.length; i++) {
+      if (originalMappings[i] != null) {
+        quickSort(originalMappings[i], util.compareByOriginalPositionsNoSource);
+      }
+    }
+    this.__originalMappings = [].concat(...originalMappings);
+  };
+  BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
+    if (aNeedle[aLineName] <= 0) {
+      throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
+    }
+    if (aNeedle[aColumnName] < 0) {
+      throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
+    }
+    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+  };
+  BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
+    for (var index = 0;index < this._generatedMappings.length; ++index) {
+      var mapping = this._generatedMappings[index];
+      if (index + 1 < this._generatedMappings.length) {
+        var nextMapping = this._generatedMappings[index + 1];
+        if (mapping.generatedLine === nextMapping.generatedLine) {
+          mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
+          continue;
+        }
+      }
+      mapping.lastGeneratedColumn = Infinity;
+    }
+  };
+  BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, "line"),
+      generatedColumn: util.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(needle, this._generatedMappings, "generatedLine", "generatedColumn", util.compareByGeneratedPositionsDeflated, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+    if (index >= 0) {
+      var mapping = this._generatedMappings[index];
+      if (mapping.generatedLine === needle.generatedLine) {
+        var source = util.getArg(mapping, "source", null);
+        if (source !== null) {
+          source = this._sources.at(source);
+          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+        }
+        var name = util.getArg(mapping, "name", null);
+        if (name !== null) {
+          name = this._names.at(name);
+        }
+        return {
+          source,
+          line: util.getArg(mapping, "originalLine", null),
+          column: util.getArg(mapping, "originalColumn", null),
+          name
+        };
+      }
+    }
+    return {
+      source: null,
+      line: null,
+      column: null,
+      name: null
+    };
+  };
+  BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
+    if (!this.sourcesContent) {
+      return false;
+    }
+    return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
+      return sc == null;
+    });
+  };
+  BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    if (!this.sourcesContent) {
+      return null;
+    }
+    var index = this._findSourceIndex(aSource);
+    if (index >= 0) {
+      return this.sourcesContent[index];
+    }
+    var relativeSource = aSource;
+    if (this.sourceRoot != null) {
+      relativeSource = util.relative(this.sourceRoot, relativeSource);
+    }
+    var url;
+    if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
+      var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
+      if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
+        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
+      }
+      if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
+        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    } else {
+      throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+    }
+  };
+  BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
+    var source = util.getArg(aArgs, "source");
+    source = this._findSourceIndex(source);
+    if (source < 0) {
+      return {
+        line: null,
+        column: null,
+        lastColumn: null
+      };
+    }
+    var needle = {
+      source,
+      originalLine: util.getArg(aArgs, "line"),
+      originalColumn: util.getArg(aArgs, "column")
+    };
+    var index = this._findMapping(needle, this._originalMappings, "originalLine", "originalColumn", util.compareByOriginalPositions, util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND));
+    if (index >= 0) {
+      var mapping = this._originalMappings[index];
+      if (mapping.source === needle.source) {
+        return {
+          line: util.getArg(mapping, "generatedLine", null),
+          column: util.getArg(mapping, "generatedColumn", null),
+          lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
+        };
+      }
+    }
+    return {
+      line: null,
+      column: null,
+      lastColumn: null
+    };
+  };
+  exports.BasicSourceMapConsumer = BasicSourceMapConsumer;
+  function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
+    var sourceMap = aSourceMap;
+    if (typeof aSourceMap === "string") {
+      sourceMap = util.parseSourceMapInput(aSourceMap);
+    }
+    var version = util.getArg(sourceMap, "version");
+    var sections = util.getArg(sourceMap, "sections");
+    if (version != this._version) {
+      throw new Error("Unsupported version: " + version);
+    }
+    this._sources = new ArraySet;
+    this._names = new ArraySet;
+    var lastOffset = {
+      line: -1,
+      column: 0
+    };
+    this._sections = sections.map(function(s) {
+      if (s.url) {
+        throw new Error("Support for url field in sections not implemented.");
+      }
+      var offset = util.getArg(s, "offset");
+      var offsetLine = util.getArg(offset, "line");
+      var offsetColumn = util.getArg(offset, "column");
+      if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
+        throw new Error("Section offsets must be ordered and non-overlapping.");
+      }
+      lastOffset = offset;
+      return {
+        generatedOffset: {
+          generatedLine: offsetLine + 1,
+          generatedColumn: offsetColumn + 1
+        },
+        consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
+      };
+    });
+  }
+  IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
+  IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
+  IndexedSourceMapConsumer.prototype._version = 3;
+  Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
+    get: function() {
+      var sources = [];
+      for (var i = 0;i < this._sections.length; i++) {
+        for (var j = 0;j < this._sections[i].consumer.sources.length; j++) {
+          sources.push(this._sections[i].consumer.sources[j]);
+        }
+      }
+      return sources;
+    }
+  });
+  IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
+    var needle = {
+      generatedLine: util.getArg(aArgs, "line"),
+      generatedColumn: util.getArg(aArgs, "column")
+    };
+    var sectionIndex = binarySearch.search(needle, this._sections, function(needle2, section2) {
+      var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
+      if (cmp) {
+        return cmp;
+      }
+      return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
+    });
+    var section = this._sections[sectionIndex];
+    if (!section) {
+      return {
+        source: null,
+        line: null,
+        column: null,
+        name: null
+      };
+    }
+    return section.consumer.originalPositionFor({
+      line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+      column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+      bias: aArgs.bias
+    });
+  };
+  IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
+    return this._sections.every(function(s) {
+      return s.consumer.hasContentsOfAllSources();
+    });
+  };
+  IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var content = section.consumer.sourceContentFor(aSource, true);
+      if (content || content === "") {
+        return content;
+      }
+    }
+    if (nullOnMissing) {
+      return null;
+    } else {
+      throw new Error('"' + aSource + '" is not in the SourceMap.');
+    }
+  };
+  IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
+        continue;
       }
-      var tmp, j;
-      i--;
-      if (i < 0)
-        return { done: true };
-      cycles[i]--;
-      if (cycles[i] === 0) {
-        tmp = indices[i];
-        for (j = i;j < n - 1; j++)
-          indices[j] = indices[j + 1];
-        indices[n - 1] = tmp;
-        cycles[i] = n - i;
-        return next();
-      } else {
-        j = cycles[i];
-        tmp = indices[i];
-        indices[i] = indices[n - j];
-        indices[n - j] = tmp;
-        i = r;
-        indicesToItems(subsequence, array, indices, r);
-        return { value: subsequence, done: false };
+      var generatedPosition = section.consumer.generatedPositionFor(aArgs);
+      if (generatedPosition) {
+        var ret = {
+          line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
+          column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
+        };
+        return ret;
       }
-    });
+    }
+    return {
+      line: null,
+      column: null
+    };
   };
-});
-
-// node_modules/obliterator/power-set.js
-var require_power_set = __commonJS((exports, module) => {
-  var Iterator = require_iterator();
-  var combinations = require_combinations();
-  var chain = require_chain();
-  module.exports = function powerSet(array) {
-    var n = array.length;
-    var iterators = new Array(n + 1);
-    iterators[0] = Iterator.of([]);
-    for (var i = 1;i < n + 1; i++)
-      iterators[i] = combinations(array, i);
-    return chain.apply(null, iterators);
+  IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
+    this.__generatedMappings = [];
+    this.__originalMappings = [];
+    for (var i = 0;i < this._sections.length; i++) {
+      var section = this._sections[i];
+      var sectionMappings = section.consumer._generatedMappings;
+      for (var j = 0;j < sectionMappings.length; j++) {
+        var mapping = sectionMappings[j];
+        var source = section.consumer._sources.at(mapping.source);
+        if (source !== null) {
+          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
+        }
+        this._sources.add(source);
+        source = this._sources.indexOf(source);
+        var name = null;
+        if (mapping.name) {
+          name = section.consumer._names.at(mapping.name);
+          this._names.add(name);
+          name = this._names.indexOf(name);
+        }
+        var adjustedMapping = {
+          source,
+          generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+          generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name
+        };
+        this.__generatedMappings.push(adjustedMapping);
+        if (typeof adjustedMapping.originalLine === "number") {
+          this.__originalMappings.push(adjustedMapping);
+        }
+      }
+    }
+    quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
+    quickSort(this.__originalMappings, util.compareByOriginalPositions);
   };
+  exports.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
 });
 
-// node_modules/obliterator/range.js
-var require_range = __commonJS((exports, module) => {
-  var Iterator = require_iterator();
-  module.exports = function range(start, end, step) {
-    if (arguments.length === 1) {
-      end = start;
-      start = 0;
+// node_modules/source-map-js/lib/source-node.js
+var require_source_node = __commonJS((exports) => {
+  var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+  var util = require_util();
+  var REGEX_NEWLINE = /(\r?\n)/;
+  var NEWLINE_CODE = 10;
+  var isSourceNode = "$$$isSourceNode$$$";
+  function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
+    this.children = [];
+    this.sourceContents = {};
+    this.line = aLine == null ? null : aLine;
+    this.column = aColumn == null ? null : aColumn;
+    this.source = aSource == null ? null : aSource;
+    this.name = aName == null ? null : aName;
+    this[isSourceNode] = true;
+    if (aChunks != null)
+      this.add(aChunks);
+  }
+  SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
+    var node = new SourceNode;
+    var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
+    var remainingLinesIndex = 0;
+    var shiftNextLine = function() {
+      var lineContents = getNextLine();
+      var newLine = getNextLine() || "";
+      return lineContents + newLine;
+      function getNextLine() {
+        return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : undefined;
+      }
+    };
+    var lastGeneratedLine = 1, lastGeneratedColumn = 0;
+    var lastMapping = null;
+    aSourceMapConsumer.eachMapping(function(mapping) {
+      if (lastMapping !== null) {
+        if (lastGeneratedLine < mapping.generatedLine) {
+          addMappingWithCode(lastMapping, shiftNextLine());
+          lastGeneratedLine++;
+          lastGeneratedColumn = 0;
+        } else {
+          var nextLine = remainingLines[remainingLinesIndex] || "";
+          var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
+          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
+          lastGeneratedColumn = mapping.generatedColumn;
+          addMappingWithCode(lastMapping, code);
+          lastMapping = mapping;
+          return;
+        }
+      }
+      while (lastGeneratedLine < mapping.generatedLine) {
+        node.add(shiftNextLine());
+        lastGeneratedLine++;
+      }
+      if (lastGeneratedColumn < mapping.generatedColumn) {
+        var nextLine = remainingLines[remainingLinesIndex] || "";
+        node.add(nextLine.substr(0, mapping.generatedColumn));
+        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
+        lastGeneratedColumn = mapping.generatedColumn;
+      }
+      lastMapping = mapping;
+    }, this);
+    if (remainingLinesIndex < remainingLines.length) {
+      if (lastMapping) {
+        addMappingWithCode(lastMapping, shiftNextLine());
+      }
+      node.add(remainingLines.splice(remainingLinesIndex).join(""));
     }
-    if (arguments.length < 3)
-      step = 1;
-    var i = start;
-    var iterator = new Iterator(function() {
-      if (i < end) {
-        var value = i;
-        i += step;
-        return { value, done: false };
+    aSourceMapConsumer.sources.forEach(function(sourceFile) {
+      var content = aSourceMapConsumer.sourceContentFor(sourceFile);
+      if (content != null) {
+        if (aRelativePath != null) {
+          sourceFile = util.join(aRelativePath, sourceFile);
+        }
+        node.setSourceContent(sourceFile, content);
       }
-      return { done: true };
     });
-    iterator.start = start;
-    iterator.end = end;
-    iterator.step = step;
-    return iterator;
+    return node;
+    function addMappingWithCode(mapping, code) {
+      if (mapping === null || mapping.source === undefined) {
+        node.add(code);
+      } else {
+        var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
+        node.add(new SourceNode(mapping.originalLine, mapping.originalColumn, source, code, mapping.name));
+      }
+    }
   };
-});
-
-// node_modules/obliterator/some.js
-var require_some = __commonJS((exports, module) => {
-  var iter = require_iter();
-  module.exports = function some(iterable, predicate) {
-    var iterator = iter(iterable);
-    var step;
-    while (step = iterator.next(), !step.done) {
-      if (predicate(step.value))
-        return true;
+  SourceNode.prototype.add = function SourceNode_add(aChunk) {
+    if (Array.isArray(aChunk)) {
+      aChunk.forEach(function(chunk) {
+        this.add(chunk);
+      }, this);
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      if (aChunk) {
+        this.children.push(aChunk);
+      }
+    } else {
+      throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
     }
-    return false;
+    return this;
   };
-});
-
-// node_modules/obliterator/split.js
-var require_split = __commonJS((exports, module) => {
-  var Iterator = require_iterator();
-  function makeGlobal(pattern) {
-    var flags = "g";
-    if (pattern.multiline)
-      flags += "m";
-    if (pattern.ignoreCase)
-      flags += "i";
-    if (pattern.sticky)
-      flags += "y";
-    if (pattern.unicode)
-      flags += "u";
-    return new RegExp(pattern.source, flags);
-  }
-  module.exports = function split(pattern, string) {
-    if (!(pattern instanceof RegExp))
-      throw new Error("obliterator/split: invalid pattern. Expecting a regular expression.");
-    if (typeof string !== "string")
-      throw new Error("obliterator/split: invalid target. Expecting a string.");
-    pattern = makeGlobal(pattern);
-    var consumed = false, current = 0;
-    return new Iterator(function() {
-      if (consumed)
-        return { done: true };
-      var match = pattern.exec(string), value, length;
-      if (match) {
-        length = match.index + match[0].length;
-        value = string.slice(current, match.index);
-        current = length;
-      } else {
-        consumed = true;
-        value = string.slice(current);
+  SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
+    if (Array.isArray(aChunk)) {
+      for (var i = aChunk.length - 1;i >= 0; i--) {
+        this.prepend(aChunk[i]);
       }
-      return { value, done: false };
-    });
+    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
+      this.children.unshift(aChunk);
+    } else {
+      throw new TypeError("Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk);
+    }
+    return this;
   };
-});
-
-// node_modules/obliterator/take.js
-var require_take = __commonJS((exports, module) => {
-  var iter = require_iter();
-  module.exports = function take(iterable, n) {
-    var l = arguments.length > 1 ? n : Infinity, array = l !== Infinity ? new Array(l) : [], step, i = 0;
-    var iterator = iter(iterable);
-    while (true) {
-      if (i === l)
-        return array;
-      step = iterator.next();
-      if (step.done) {
-        if (i !== n)
-          array.length = i;
-        return array;
+  SourceNode.prototype.walk = function SourceNode_walk(aFn) {
+    var chunk;
+    for (var i = 0, len = this.children.length;i < len; i++) {
+      chunk = this.children[i];
+      if (chunk[isSourceNode]) {
+        chunk.walk(aFn);
+      } else {
+        if (chunk !== "") {
+          aFn(chunk, {
+            source: this.source,
+            line: this.line,
+            column: this.column,
+            name: this.name
+          });
+        }
       }
-      array[i++] = step.value;
     }
   };
-});
-
-// node_modules/obliterator/take-into.js
-var require_take_into = __commonJS((exports, module) => {
-  var iter = require_iter();
-  module.exports = function takeInto(ArrayClass, iterable, n) {
-    var array = new ArrayClass(n), step, i = 0;
-    var iterator = iter(iterable);
-    while (true) {
-      if (i === n)
-        return array;
-      step = iterator.next();
-      if (step.done) {
-        if (i !== n)
-          return array.slice(0, i);
-        return array;
+  SourceNode.prototype.join = function SourceNode_join(aSep) {
+    var newChildren;
+    var i;
+    var len = this.children.length;
+    if (len > 0) {
+      newChildren = [];
+      for (i = 0;i < len - 1; i++) {
+        newChildren.push(this.children[i]);
+        newChildren.push(aSep);
+      }
+      newChildren.push(this.children[i]);
+      this.children = newChildren;
+    }
+    return this;
+  };
+  SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
+    var lastChild = this.children[this.children.length - 1];
+    if (lastChild[isSourceNode]) {
+      lastChild.replaceRight(aPattern, aReplacement);
+    } else if (typeof lastChild === "string") {
+      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
+    } else {
+      this.children.push("".replace(aPattern, aReplacement));
+    }
+    return this;
+  };
+  SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
+    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
+  };
+  SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
+    for (var i = 0, len = this.children.length;i < len; i++) {
+      if (this.children[i][isSourceNode]) {
+        this.children[i].walkSourceContents(aFn);
       }
-      array[i++] = step.value;
     }
+    var sources = Object.keys(this.sourceContents);
+    for (var i = 0, len = sources.length;i < len; i++) {
+      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+    }
+  };
+  SourceNode.prototype.toString = function SourceNode_toString() {
+    var str = "";
+    this.walk(function(chunk) {
+      str += chunk;
+    });
+    return str;
+  };
+  SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
+    var generated = {
+      code: "",
+      line: 1,
+      column: 0
+    };
+    var map = new SourceMapGenerator(aArgs);
+    var sourceMappingActive = false;
+    var lastOriginalSource = null;
+    var lastOriginalLine = null;
+    var lastOriginalColumn = null;
+    var lastOriginalName = null;
+    this.walk(function(chunk, original) {
+      generated.code += chunk;
+      if (original.source !== null && original.line !== null && original.column !== null) {
+        if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
+          map.addMapping({
+            source: original.source,
+            original: {
+              line: original.line,
+              column: original.column
+            },
+            generated: {
+              line: generated.line,
+              column: generated.column
+            },
+            name: original.name
+          });
+        }
+        lastOriginalSource = original.source;
+        lastOriginalLine = original.line;
+        lastOriginalColumn = original.column;
+        lastOriginalName = original.name;
+        sourceMappingActive = true;
+      } else if (sourceMappingActive) {
+        map.addMapping({
+          generated: {
+            line: generated.line,
+            column: generated.column
+          }
+        });
+        lastOriginalSource = null;
+        sourceMappingActive = false;
+      }
+      for (var idx = 0, length = chunk.length;idx < length; idx++) {
+        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
+          generated.line++;
+          generated.column = 0;
+          if (idx + 1 === length) {
+            lastOriginalSource = null;
+            sourceMappingActive = false;
+          } else if (sourceMappingActive) {
+            map.addMapping({
+              source: original.source,
+              original: {
+                line: original.line,
+                column: original.column
+              },
+              generated: {
+                line: generated.line,
+                column: generated.column
+              },
+              name: original.name
+            });
+          }
+        } else {
+          generated.column++;
+        }
+      }
+    });
+    this.walkSourceContents(function(sourceFile, sourceContent) {
+      map.setSourceContent(sourceFile, sourceContent);
+    });
+    return { code: generated.code, map };
   };
+  exports.SourceNode = SourceNode;
 });
 
 // node_modules/adm-zip/util/constants.js
@@ -4942,7 +6786,7 @@ var require_decoder = __commonJS((exports, module) => {
 });
 
 // node_modules/adm-zip/util/index.js
-var require_util = __commonJS((exports, module) => {
+var require_util2 = __commonJS((exports, module) => {
   module.exports = require_utils3();
   module.exports.Constants = require_constants();
   module.exports.Errors = require_errors();
@@ -4952,7 +6796,7 @@ var require_util = __commonJS((exports, module) => {
 
 // node_modules/adm-zip/headers/entryHeader.js
 var require_entryHeader = __commonJS((exports, module) => {
-  var Utils = require_util();
+  var Utils = require_util2();
   var Constants = Utils.Constants;
   module.exports = function() {
     var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
@@ -5217,7 +7061,7 @@ var require_entryHeader = __commonJS((exports, module) => {
 
 // node_modules/adm-zip/headers/mainHeader.js
 var require_mainHeader = __commonJS((exports, module) => {
-  var Utils = require_util();
+  var Utils = require_util2();
   var Constants = Utils.Constants;
   module.exports = function() {
     var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
@@ -5503,7 +7347,7 @@ var require_methods = __commonJS((exports) => {
 
 // node_modules/adm-zip/zipEntry.js
 var require_zipEntry = __commonJS((exports, module) => {
-  var Utils = require_util();
+  var Utils = require_util2();
   var Headers = require_headers();
   var Constants = Utils.Constants;
   var Methods = require_methods();
@@ -5841,7 +7685,7 @@ var require_zipEntry = __commonJS((exports, module) => {
 var require_zipFile = __commonJS((exports, module) => {
   var ZipEntry = require_zipEntry();
   var Headers = require_headers();
-  var Utils = require_util();
+  var Utils = require_util2();
   module.exports = function(inBuffer, options) {
     var entryList = [], entryTable = {}, _comment = Buffer.alloc(0), mainHeader = new Headers.MainHeader, loadedEntries = false;
     var password = null;
@@ -6142,7 +7986,7 @@ var require_zipFile = __commonJS((exports, module) => {
 
 // node_modules/adm-zip/adm-zip.js
 var require_adm_zip = __commonJS((exports, module) => {
-  var Utils = require_util();
+  var Utils = require_util2();
   var pth = __require("path");
   var ZipEntry = require_zipEntry();
   var ZipFile = require_zipFile();
@@ -6466,12 +8310,12 @@ var require_adm_zip = __commonJS((exports, module) => {
         });
       },
       addLocalFolderPromise: function(localPath2, props) {
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           this.addLocalFolderAsync2(Object.assign({ localPath: localPath2 }, props), (err, done) => {
             if (err)
               reject(err);
             if (done)
-              resolve(this);
+              resolve2(this);
           });
         });
       },
@@ -6603,12 +8447,12 @@ var require_adm_zip = __commonJS((exports, module) => {
         keepOriginalPermission = get_Bool(false, keepOriginalPermission);
         overwrite = get_Bool(false, overwrite);
         if (!callback) {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             this.extractAllToAsync(targetPath, overwrite, keepOriginalPermission, function(err) {
               if (err) {
                 reject(err);
               } else {
-                resolve(this);
+                resolve2(this);
               }
             });
           });
@@ -6694,20 +8538,20 @@ var require_adm_zip = __commonJS((exports, module) => {
       },
       writeZipPromise: function(targetFileName, props) {
         const { overwrite, perm } = Object.assign({ overwrite: true }, props);
-        return new Promise((resolve, reject) => {
+        return new Promise((resolve2, reject) => {
           if (!targetFileName && opts.filename)
             targetFileName = opts.filename;
           if (!targetFileName)
             reject("ADM-ZIP: ZIP File Name Missing");
           this.toBufferPromise().then((zipData) => {
-            const ret = (done) => done ? resolve(done) : reject("ADM-ZIP: Wasn't able to write zip file");
+            const ret = (done) => done ? resolve2(done) : reject("ADM-ZIP: Wasn't able to write zip file");
             filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
           }, reject);
         });
       },
       toBufferPromise: function() {
-        return new Promise((resolve, reject) => {
-          _zip.toAsyncBuffer(resolve, reject);
+        return new Promise((resolve2, reject) => {
+          _zip.toAsyncBuffer(resolve2, reject);
         });
       },
       toBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
@@ -8861,14 +10705,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve2, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve2, reject);
             });
             return;
           } catch (error) {
@@ -8876,7 +10720,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve2(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -9052,14 +10896,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve, reject) {
+          then: function(resolve2, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve2, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -9070,7 +10914,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve(returnValue);
+                resolve2(returnValue);
             }, function(error) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error)) : reject(error);
@@ -9086,11 +10930,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve, reject) {
+        then: function(resolve2, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve, reject);
-          })) : resolve(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve2, reject);
+          })) : resolve2(returnValue$jscomp$0);
         }
       };
     };
@@ -9329,8 +11173,9 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
 
 // node_modules/react/index.js
 var require_react = __commonJS((exports, module) => {
+  var react_development = __toESM(require_react_development());
   if (false) {} else {
-    module.exports = require_react_development();
+    module.exports = react_development;
   }
 });
 
@@ -9392,14 +11237,14 @@ var require_signal_exit = __commonJS((exports, module) => {
       if (opts && opts.alwaysLast) {
         ev = "afterexit";
       }
-      var remove = function() {
+      var remove2 = function() {
         emitter.removeListener(ev, cb);
         if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
           unload();
         }
       };
       emitter.on(ev, cb);
-      return remove;
+      return remove2;
     };
     unload = function unload2() {
       if (!loaded || !processOk(global.process)) {
@@ -9590,16 +11435,16 @@ var require_scheduler_development = __commonJS((exports) => {
     function pop(heap) {
       if (heap.length === 0)
         return null;
-      var first = heap[0], last = heap.pop();
-      if (last !== first) {
-        heap[0] = last;
+      var first = heap[0], last2 = heap.pop();
+      if (last2 !== first) {
+        heap[0] = last2;
         a:
           for (var index = 0, length = heap.length, halfLength = length >>> 1;index < halfLength; ) {
             var leftIndex = 2 * (index + 1) - 1, left = heap[leftIndex], rightIndex = leftIndex + 1, right = heap[rightIndex];
-            if (0 > compare(left, last))
-              rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last, index = leftIndex);
-            else if (rightIndex < length && 0 > compare(right, last))
-              heap[index] = right, heap[rightIndex] = last, index = rightIndex;
+            if (0 > compare(left, last2))
+              rightIndex < length && 0 > compare(right, left) ? (heap[index] = right, heap[rightIndex] = last2, index = rightIndex) : (heap[index] = left, heap[leftIndex] = last2, index = leftIndex);
+            else if (rightIndex < length && 0 > compare(right, last2))
+              heap[index] = right, heap[rightIndex] = last2, index = rightIndex;
             else
               break a;
           }
@@ -9773,8 +11618,9 @@ var require_scheduler_development = __commonJS((exports) => {
 
 // node_modules/scheduler/index.js
 var require_scheduler = __commonJS((exports, module) => {
+  var scheduler_development = __toESM(require_scheduler_development());
   if (false) {} else {
-    module.exports = require_scheduler_development();
+    module.exports = scheduler_development;
   }
 });
 
@@ -9791,7 +11637,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
     function copyWithSetImpl(obj, path11, index, value) {
       if (index >= path11.length)
         return value;
-      var key = path11[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      var key = path11[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
       updated[key] = copyWithSetImpl(obj[key], path11, index + 1, value);
       return updated;
     }
@@ -9808,12 +11654,12 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       }
     }
     function copyWithRenameImpl(obj, oldPath, newPath, index) {
-      var oldKey = oldPath[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      var oldKey = oldPath[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
       index + 1 === oldPath.length ? (updated[newPath[index]] = updated[oldKey], isArrayImpl(updated) ? updated.splice(oldKey, 1) : delete updated[oldKey]) : updated[oldKey] = copyWithRenameImpl(obj[oldKey], oldPath, newPath, index + 1);
       return updated;
     }
     function copyWithDeleteImpl(obj, path11, index) {
-      var key = path11[index], updated = isArrayImpl(obj) ? obj.slice() : assign({}, obj);
+      var key = path11[index], updated = isArrayImpl(obj) ? obj.slice() : assign2({}, obj);
       if (index + 1 === path11.length)
         return isArrayImpl(updated) ? updated.splice(key, 1) : delete updated[key], updated;
       updated[key] = copyWithDeleteImpl(obj[key], path11, index + 1);
@@ -9831,12 +11677,12 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
     function scheduleRoot(root, element) {
       root.context === emptyContextObject && (updateContainerSync(element, root, null, null), flushSyncWork());
     }
-    function scheduleRefresh(root, update) {
+    function scheduleRefresh(root, update2) {
       if (resolveFamily !== null) {
-        var staleFamilies = update.staleFamilies;
-        update = update.updatedFamilies;
+        var staleFamilies = update2.staleFamilies;
+        update2 = update2.updatedFamilies;
         flushPendingEffects();
-        scheduleFibersWithFamiliesRecursively(root.current, update, staleFamilies);
+        scheduleFibersWithFamiliesRecursively(root.current, update2, staleFamilies);
         flushSyncWork();
       }
     }
@@ -9849,11 +11695,11 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
     function warnInvalidContextAccess() {
       console.error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo().");
     }
-    function noop() {}
+    function noop2() {}
     function warnForMissingKey() {}
-    function setToSortedString(set) {
+    function setToSortedString(set2) {
       var array = [];
-      set.forEach(function(value) {
+      set2.forEach(function(value) {
         array.push(value);
       });
       return array.sort().join(", ");
@@ -10225,9 +12071,9 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       (nextRetryLane & 62914560) === 0 && (nextRetryLane = 4194304);
       return lane;
     }
-    function createLaneMap(initial) {
+    function createLaneMap(initial2) {
       for (var laneMap = [], i = 0;31 > i; i++)
-        laneMap.push(initial);
+        laneMap.push(initial2);
       return laneMap;
     }
     function markRootUpdated$1(root, updateLane) {
@@ -10252,8 +12098,8 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
         var hiddenUpdatesForLane = hiddenUpdates[index];
         if (hiddenUpdatesForLane !== null)
           for (hiddenUpdates[index] = null, index = 0;index < hiddenUpdatesForLane.length; index++) {
-            var update = hiddenUpdatesForLane[index];
-            update !== null && (update.lane &= -536870913);
+            var update2 = hiddenUpdatesForLane[index];
+            update2 !== null && (update2.lane &= -536870913);
           }
         remainingLanes &= ~lane;
       }
@@ -10738,13 +12584,13 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       if (disabledDepth === 0) {
         var props = { configurable: true, enumerable: true, writable: true };
         Object.defineProperties(console, {
-          log: assign({}, props, { value: prevLog }),
-          info: assign({}, props, { value: prevInfo }),
-          warn: assign({}, props, { value: prevWarn }),
-          error: assign({}, props, { value: prevError }),
-          group: assign({}, props, { value: prevGroup }),
-          groupCollapsed: assign({}, props, { value: prevGroupCollapsed }),
-          groupEnd: assign({}, props, { value: prevGroupEnd })
+          log: assign2({}, props, { value: prevLog }),
+          info: assign2({}, props, { value: prevInfo }),
+          warn: assign2({}, props, { value: prevWarn }),
+          error: assign2({}, props, { value: prevError }),
+          group: assign2({}, props, { value: prevGroup }),
+          groupCollapsed: assign2({}, props, { value: prevGroupCollapsed }),
+          groupEnd: assign2({}, props, { value: prevGroupEnd })
         });
       }
       0 > disabledDepth && console.error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
@@ -10830,9 +12676,9 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
                 }
                 (Fake = fn()) && typeof Fake.catch === "function" && Fake.catch(function() {});
               }
-            } catch (sample) {
-              if (sample && control && typeof sample.stack === "string")
-                return [sample.stack, control.stack];
+            } catch (sample2) {
+              if (sample2 && control && typeof sample2.stack === "string")
+                return [sample2.stack, control.stack];
             }
             return [null, null];
           }
@@ -11161,7 +13007,7 @@ Error generating stack: ` + x.message + `
 `;
     }
     function describePropertiesDiff(clientObject, serverObject, indent) {
-      var properties = "", remainingServerProperties = assign({}, serverObject), propName;
+      var properties = "", remainingServerProperties = assign2({}, serverObject), propName;
       for (propName in clientObject)
         if (clientObject.hasOwnProperty(propName)) {
           delete remainingServerProperties[propName];
@@ -11663,21 +13509,21 @@ It can also happen if the client has a browser extension installed which messes
         cache2.controller.abort();
       });
     }
-    function startUpdateTimerByLane(lane, method, fiber) {
+    function startUpdateTimerByLane(lane, method2, fiber) {
       if ((lane & 127) !== 0)
-        0 > blockingUpdateTime && (blockingUpdateTime = now(), blockingUpdateTask = createTask(method), blockingUpdateMethodName = method, fiber != null && (blockingUpdateComponentName = getComponentNameFromFiber(fiber)), isAlreadyRendering() && (componentEffectSpawnedUpdate = true, blockingUpdateType = 1), lane = resolveEventTimeStamp(), method = resolveEventType(), lane !== blockingEventRepeatTime || method !== blockingEventType ? blockingEventRepeatTime = -1.1 : method !== null && (blockingUpdateType = 1), blockingEventTime = lane, blockingEventType = method);
-      else if ((lane & 4194048) !== 0 && 0 > transitionUpdateTime && (transitionUpdateTime = now(), transitionUpdateTask = createTask(method), transitionUpdateMethodName = method, fiber != null && (transitionUpdateComponentName = getComponentNameFromFiber(fiber)), 0 > transitionStartTime)) {
+        0 > blockingUpdateTime && (blockingUpdateTime = now2(), blockingUpdateTask = createTask(method2), blockingUpdateMethodName = method2, fiber != null && (blockingUpdateComponentName = getComponentNameFromFiber(fiber)), isAlreadyRendering() && (componentEffectSpawnedUpdate = true, blockingUpdateType = 1), lane = resolveEventTimeStamp(), method2 = resolveEventType(), lane !== blockingEventRepeatTime || method2 !== blockingEventType ? blockingEventRepeatTime = -1.1 : method2 !== null && (blockingUpdateType = 1), blockingEventTime = lane, blockingEventType = method2);
+      else if ((lane & 4194048) !== 0 && 0 > transitionUpdateTime && (transitionUpdateTime = now2(), transitionUpdateTask = createTask(method2), transitionUpdateMethodName = method2, fiber != null && (transitionUpdateComponentName = getComponentNameFromFiber(fiber)), 0 > transitionStartTime)) {
         lane = resolveEventTimeStamp();
-        method = resolveEventType();
-        if (lane !== transitionEventRepeatTime || method !== transitionEventType)
+        method2 = resolveEventType();
+        if (lane !== transitionEventRepeatTime || method2 !== transitionEventType)
           transitionEventRepeatTime = -1.1;
         transitionEventTime = lane;
-        transitionEventType = method;
+        transitionEventType = method2;
       }
     }
     function startHostActionTimer(fiber) {
       if (0 > blockingUpdateTime) {
-        blockingUpdateTime = now();
+        blockingUpdateTime = now2();
         blockingUpdateTask = fiber._debugTask != null ? fiber._debugTask : null;
         isAlreadyRendering() && (blockingUpdateType = 1);
         var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
@@ -11685,7 +13531,7 @@ It can also happen if the client has a browser extension installed which messes
         blockingEventTime = newEventTime;
         blockingEventType = newEventType;
       }
-      if (0 > transitionUpdateTime && (transitionUpdateTime = now(), transitionUpdateTask = fiber._debugTask != null ? fiber._debugTask : null, 0 > transitionStartTime)) {
+      if (0 > transitionUpdateTime && (transitionUpdateTime = now2(), transitionUpdateTask = fiber._debugTask != null ? fiber._debugTask : null, 0 > transitionStartTime)) {
         fiber = resolveEventTimeStamp();
         newEventTime = resolveEventType();
         if (fiber !== transitionEventRepeatTime || newEventTime !== transitionEventType)
@@ -11739,12 +13585,12 @@ It can also happen if the client has a browser extension installed which messes
       return prev;
     }
     function startProfilerTimer(fiber) {
-      profilerStartTime = now();
+      profilerStartTime = now2();
       0 > fiber.actualStartTime && (fiber.actualStartTime = profilerStartTime);
     }
     function stopProfilerTimerIfRunningAndRecordDuration(fiber) {
       if (0 <= profilerStartTime) {
-        var elapsedTime = now() - profilerStartTime;
+        var elapsedTime = now2() - profilerStartTime;
         fiber.actualDuration += elapsedTime;
         fiber.selfBaseDuration = elapsedTime;
         profilerStartTime = -1;
@@ -11752,14 +13598,14 @@ It can also happen if the client has a browser extension installed which messes
     }
     function stopProfilerTimerIfRunningAndRecordIncompleteDuration(fiber) {
       if (0 <= profilerStartTime) {
-        var elapsedTime = now() - profilerStartTime;
+        var elapsedTime = now2() - profilerStartTime;
         fiber.actualDuration += elapsedTime;
         profilerStartTime = -1;
       }
     }
     function recordEffectDuration() {
       if (0 <= profilerStartTime) {
-        var endTime = now(), elapsedTime = endTime - profilerStartTime;
+        var endTime = now2(), elapsedTime = endTime - profilerStartTime;
         profilerStartTime = -1;
         profilerEffectDuration += elapsedTime;
         componentEffectDuration += elapsedTime;
@@ -11773,7 +13619,7 @@ It can also happen if the client has a browser extension installed which messes
       commitErrors.push(errorInfo);
     }
     function startEffectTimer() {
-      profilerStartTime = now();
+      profilerStartTime = now2();
       0 > componentEffectStartTime && (componentEffectStartTime = profilerStartTime);
     }
     function transferActualDuration(fiber) {
@@ -11930,8 +13776,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve) {
-            entangledListeners.push(resolve);
+          then: function(resolve2) {
+            entangledListeners.push(resolve2);
           }
         };
       }
@@ -11950,20 +13796,20 @@ It can also happen if the client has a browser extension installed which messes
           (0, listeners[i])();
       }
     }
-    function chainThenableValue(thenable, result) {
+    function chainThenableValue(thenable, result2) {
       var listeners = [], thenableWithOverride = {
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve) {
-          listeners.push(resolve);
+        then: function(resolve2) {
+          listeners.push(resolve2);
         }
       };
       thenable.then(function() {
         thenableWithOverride.status = "fulfilled";
-        thenableWithOverride.value = result;
+        thenableWithOverride.value = result2;
         for (var i = 0;i < listeners.length; i++)
-          (0, listeners[i])(result);
+          (0, listeners[i])(result2);
       }, function(error) {
         thenableWithOverride.status = "rejected";
         thenableWithOverride.reason = error;
@@ -12105,8 +13951,8 @@ It can also happen if the client has a browser extension installed which messes
       return null;
     }
     function validateFragmentProps(element, fiber, returnFiber) {
-      for (var keys = Object.keys(element.props), i = 0;i < keys.length; i++) {
-        var key = keys[i];
+      for (var keys2 = Object.keys(element.props), i = 0;i < keys2.length; i++) {
+        var key = keys2[i];
         if (key !== "children" && key !== "key") {
           fiber === null && (fiber = createFiberFromElement(element, returnFiber.mode, 0), fiber._debugInfo = currentDebugInfo, fiber.return = returnFiber);
           runWithFiberInDEV(fiber, function(erroredKey) {
@@ -12553,43 +14399,43 @@ It can also happen if the client has a browser extension installed which messes
         concurrentQueues[i++] = null;
         var queue = concurrentQueues[i];
         concurrentQueues[i++] = null;
-        var update = concurrentQueues[i];
+        var update2 = concurrentQueues[i];
         concurrentQueues[i++] = null;
         var lane = concurrentQueues[i];
         concurrentQueues[i++] = null;
-        if (queue !== null && update !== null) {
+        if (queue !== null && update2 !== null) {
           var pending = queue.pending;
-          pending === null ? update.next = update : (update.next = pending.next, pending.next = update);
-          queue.pending = update;
+          pending === null ? update2.next = update2 : (update2.next = pending.next, pending.next = update2);
+          queue.pending = update2;
         }
-        lane !== 0 && markUpdateLaneFromFiberToRoot(fiber, update, lane);
+        lane !== 0 && markUpdateLaneFromFiberToRoot(fiber, update2, lane);
       }
     }
-    function enqueueUpdate$1(fiber, queue, update, lane) {
+    function enqueueUpdate$1(fiber, queue, update2, lane) {
       concurrentQueues[concurrentQueuesIndex++] = fiber;
       concurrentQueues[concurrentQueuesIndex++] = queue;
-      concurrentQueues[concurrentQueuesIndex++] = update;
+      concurrentQueues[concurrentQueuesIndex++] = update2;
       concurrentQueues[concurrentQueuesIndex++] = lane;
       concurrentlyUpdatedLanes |= lane;
       fiber.lanes |= lane;
       fiber = fiber.alternate;
       fiber !== null && (fiber.lanes |= lane);
     }
-    function enqueueConcurrentHookUpdate(fiber, queue, update, lane) {
-      enqueueUpdate$1(fiber, queue, update, lane);
+    function enqueueConcurrentHookUpdate(fiber, queue, update2, lane) {
+      enqueueUpdate$1(fiber, queue, update2, lane);
       return getRootForUpdatedFiber(fiber);
     }
     function enqueueConcurrentRenderForLane(fiber, lane) {
       enqueueUpdate$1(fiber, null, null, lane);
       return getRootForUpdatedFiber(fiber);
     }
-    function markUpdateLaneFromFiberToRoot(sourceFiber, update, lane) {
+    function markUpdateLaneFromFiberToRoot(sourceFiber, update2, lane) {
       sourceFiber.lanes |= lane;
       var alternate = sourceFiber.alternate;
       alternate !== null && (alternate.lanes |= lane);
       for (var isHidden = false, parent = sourceFiber.return;parent !== null; )
         parent.childLanes |= lane, alternate = parent.alternate, alternate !== null && (alternate.childLanes |= lane), parent.tag === 22 && (sourceFiber = parent.stateNode, sourceFiber === null || sourceFiber._visibility & OffscreenVisible || (isHidden = true)), sourceFiber = parent, parent = parent.return;
-      return sourceFiber.tag === 3 ? (parent = sourceFiber.stateNode, isHidden && update !== null && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], alternate === null ? sourceFiber[isHidden] = [update] : alternate.push(update), update.lane = lane | 536870912), parent) : null;
+      return sourceFiber.tag === 3 ? (parent = sourceFiber.stateNode, isHidden && update2 !== null && (isHidden = 31 - clz32(lane), sourceFiber = parent.hiddenUpdates, alternate = sourceFiber[isHidden], alternate === null ? sourceFiber[isHidden] = [update2] : alternate.push(update2), update2.lane = lane | 536870912), parent) : null;
     }
     function getRootForUpdatedFiber(sourceFiber) {
       if (nestedUpdateCount > NESTED_UPDATE_LIMIT)
@@ -12628,7 +14474,7 @@ It can also happen if the client has a browser extension installed which messes
         next: null
       };
     }
-    function enqueueUpdate(fiber, update, lane) {
+    function enqueueUpdate(fiber, update2, lane) {
       var updateQueue = fiber.updateQueue;
       if (updateQueue === null)
         return null;
@@ -12641,8 +14487,8 @@ Please update the following component: %s`, componentName2);
         didWarnUpdateInsideUpdate = true;
       }
       if ((executionContext & RenderContext) !== NoContext)
-        return componentName2 = updateQueue.pending, componentName2 === null ? update.next = update : (update.next = componentName2.next, componentName2.next = update), updateQueue.pending = update, update = getRootForUpdatedFiber(fiber), markUpdateLaneFromFiberToRoot(fiber, null, lane), update;
-      enqueueUpdate$1(fiber, updateQueue, update, lane);
+        return componentName2 = updateQueue.pending, componentName2 === null ? update2.next = update2 : (update2.next = componentName2.next, componentName2.next = update2), updateQueue.pending = update2, update2 = getRootForUpdatedFiber(fiber), markUpdateLaneFromFiberToRoot(fiber, null, lane), update2;
+      enqueueUpdate$1(fiber, updateQueue, update2, lane);
       return getRootForUpdatedFiber(fiber);
     }
     function entangleTransitions(root, fiber, lane) {
@@ -12662,14 +14508,14 @@ Please update the following component: %s`, componentName2);
         queue = queue.firstBaseUpdate;
         if (queue !== null) {
           do {
-            var clone = {
+            var clone2 = {
               lane: queue.lane,
               tag: queue.tag,
               payload: queue.payload,
               callback: null,
               next: null
             };
-            newLast === null ? newFirst = newLast = clone : newLast = newLast.next = clone;
+            newLast === null ? newFirst = newLast = clone2 : newLast = newLast.next = clone2;
             queue = queue.next;
           } while (queue !== null);
           newLast === null ? newFirst = newLast = capturedUpdate : newLast = newLast.next = capturedUpdate;
@@ -12771,7 +14617,7 @@ Please update the following component: %s`, componentName2);
                     partialState = nextState;
                   if (partialState === null || partialState === undefined)
                     break a;
-                  newState = assign({}, newState, partialState);
+                  newState = assign2({}, newState, partialState);
                   break a;
                 case ForceUpdate:
                   hasForceUpdate = true;
@@ -13107,7 +14953,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       }
       throw Error("An unsupported type was passed to use(): " + String(usable));
     }
-    function useMemoCache(size) {
+    function useMemoCache(size2) {
       var memoCache = null, updateQueue = currentlyRenderingFiber.updateQueue;
       updateQueue !== null && (memoCache = updateQueue.memoCache);
       if (memoCache == null) {
@@ -13124,10 +14970,10 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       updateQueue.memoCache = memoCache;
       updateQueue = memoCache.data[memoCache.index];
       if (updateQueue === undefined || ignorePreviousDependencies)
-        for (updateQueue = memoCache.data[memoCache.index] = Array(size), current2 = 0;current2 < size; current2++)
+        for (updateQueue = memoCache.data[memoCache.index] = Array(size2), current2 = 0;current2 < size2; current2++)
           updateQueue[current2] = REACT_MEMO_CACHE_SENTINEL;
       else
-        updateQueue.length !== size && console.error("Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.", updateQueue.length, size);
+        updateQueue.length !== size2 && console.error("Expected a constant size argument for each invocation of useMemoCache. The previous cache was allocated with size %s but size %s was requested.", updateQueue.length, size2);
       memoCache.index++;
       return updateQueue;
     }
@@ -13185,50 +15031,50 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
         hook.memoizedState = pendingQueue;
       else {
         current2 = baseQueue.next;
-        var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update = current2, didReadFromEntangledAsyncAction2 = false;
+        var newBaseQueueFirst = baseFirst = null, newBaseQueueLast = null, update2 = current2, didReadFromEntangledAsyncAction2 = false;
         do {
-          var updateLane = update.lane & -536870913;
-          if (updateLane !== update.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
-            var revertLane = update.revertLane;
+          var updateLane = update2.lane & -536870913;
+          if (updateLane !== update2.lane ? (workInProgressRootRenderLanes & updateLane) === updateLane : (renderLanes & updateLane) === updateLane) {
+            var revertLane = update2.revertLane;
             if (revertLane === 0)
               newBaseQueueLast !== null && (newBaseQueueLast = newBaseQueueLast.next = {
                 lane: 0,
                 revertLane: 0,
                 gesture: null,
-                action: update.action,
-                hasEagerState: update.hasEagerState,
-                eagerState: update.eagerState,
+                action: update2.action,
+                hasEagerState: update2.hasEagerState,
+                eagerState: update2.eagerState,
                 next: null
               }), updateLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
             else if ((renderLanes & revertLane) === revertLane) {
-              update = update.next;
+              update2 = update2.next;
               revertLane === currentEntangledLane && (didReadFromEntangledAsyncAction2 = true);
               continue;
             } else
               updateLane = {
                 lane: 0,
-                revertLane: update.revertLane,
+                revertLane: update2.revertLane,
                 gesture: null,
-                action: update.action,
-                hasEagerState: update.hasEagerState,
-                eagerState: update.eagerState,
+                action: update2.action,
+                hasEagerState: update2.hasEagerState,
+                eagerState: update2.eagerState,
                 next: null
               }, newBaseQueueLast === null ? (newBaseQueueFirst = newBaseQueueLast = updateLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = updateLane, currentlyRenderingFiber.lanes |= revertLane, workInProgressRootSkippedLanes |= revertLane;
-            updateLane = update.action;
+            updateLane = update2.action;
             shouldDoubleInvokeUserFnsInHooksDEV && reducer(pendingQueue, updateLane);
-            pendingQueue = update.hasEagerState ? update.eagerState : reducer(pendingQueue, updateLane);
+            pendingQueue = update2.hasEagerState ? update2.eagerState : reducer(pendingQueue, updateLane);
           } else
             revertLane = {
               lane: updateLane,
-              revertLane: update.revertLane,
-              gesture: update.gesture,
-              action: update.action,
-              hasEagerState: update.hasEagerState,
-              eagerState: update.eagerState,
+              revertLane: update2.revertLane,
+              gesture: update2.gesture,
+              action: update2.action,
+              hasEagerState: update2.hasEagerState,
+              eagerState: update2.eagerState,
               next: null
             }, newBaseQueueLast === null ? (newBaseQueueFirst = newBaseQueueLast = revertLane, baseFirst = pendingQueue) : newBaseQueueLast = newBaseQueueLast.next = revertLane, currentlyRenderingFiber.lanes |= updateLane, workInProgressRootSkippedLanes |= updateLane;
-          update = update.next;
-        } while (update !== null && update !== current2);
+          update2 = update2.next;
+        } while (update2 !== null && update2 !== current2);
         newBaseQueueLast === null ? baseFirst = pendingQueue : newBaseQueueLast.next = newBaseQueueFirst;
         if (!objectIs(pendingQueue, hook.memoizedState) && (didReceiveUpdate = true, didReadFromEntangledAsyncAction2 && (reducer = currentEntangledActionThenable, reducer !== null)))
           throw reducer;
@@ -13248,10 +15094,10 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       var { dispatch, pending: lastRenderPhaseUpdate } = queue, newState = hook.memoizedState;
       if (lastRenderPhaseUpdate !== null) {
         queue.pending = null;
-        var update = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
+        var update2 = lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
         do
-          newState = reducer(newState, update.action), update = update.next;
-        while (update !== lastRenderPhaseUpdate);
+          newState = reducer(newState, update2.action), update2 = update2.next;
+        while (update2 !== lastRenderPhaseUpdate);
         objectIs(newState, hook.memoizedState) || (didReceiveUpdate = true);
         hook.memoizedState = newState;
         hook.baseQueue === null && (hook.baseState = newState);
@@ -13294,8 +15140,8 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       if (cachedSnapshot = !objectIs((currentHook || hook).memoizedState, getServerSnapshot))
         hook.memoizedState = getServerSnapshot, didReceiveUpdate = true;
       hook = hook.queue;
-      var create = subscribeToStore.bind(null, fiber, hook, subscribe);
-      updateEffectImpl(2048, Passive, create, [subscribe]);
+      var create2 = subscribeToStore.bind(null, fiber, hook, subscribe);
+      updateEffectImpl(2048, Passive, create2, [subscribe]);
       if (hook.getSnapshot !== getSnapshot || cachedSnapshot || workInProgressHook !== null && workInProgressHook.memoizedState.tag & HasEffect) {
         fiber.flags |= 2048;
         pushSimpleEffect(HasEffect | Passive, { destroy: undefined }, updateStoreInstance.bind(null, fiber, hook, getServerSnapshot, getSnapshot), null);
@@ -13457,13 +15303,13 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       actionNode !== null && (nextState = actionNode.next, nextState === actionNode ? actionQueue.pending = null : (nextState = nextState.next, actionNode.next = nextState, runActionStateAction(actionQueue, nextState)));
     }
     function onActionError(actionQueue, actionNode, error) {
-      var last = actionQueue.pending;
+      var last2 = actionQueue.pending;
       actionQueue.pending = null;
-      if (last !== null) {
-        last = last.next;
+      if (last2 !== null) {
+        last2 = last2.next;
         do
           actionNode.status = "rejected", actionNode.reason = error, notifyActionListeners(actionNode), actionNode = actionNode.next;
-        while (actionNode !== last);
+        while (actionNode !== last2);
       }
       actionQueue.action = null;
     }
@@ -13560,12 +15406,12 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       currentStateHook.memoizedState = action;
       return [stateHook, dispatch, false];
     }
-    function pushSimpleEffect(tag, inst, create, deps) {
-      tag = { tag, create, deps, inst, next: null };
+    function pushSimpleEffect(tag, inst, create2, deps) {
+      tag = { tag, create: create2, deps, inst, next: null };
       inst = currentlyRenderingFiber.updateQueue;
       inst === null && (inst = createFunctionComponentUpdateQueue(), currentlyRenderingFiber.updateQueue = inst);
-      create = inst.lastEffect;
-      create === null ? inst.lastEffect = tag.next = tag : (deps = create.next, create.next = tag, tag.next = deps, inst.lastEffect = tag);
+      create2 = inst.lastEffect;
+      create2 === null ? inst.lastEffect = tag.next = tag : (deps = create2.next, create2.next = tag, tag.next = deps, inst.lastEffect = tag);
       return tag;
     }
     function mountRef(initialValue) {
@@ -13573,19 +15419,19 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       initialValue = { current: initialValue };
       return hook.memoizedState = initialValue;
     }
-    function mountEffectImpl(fiberFlags, hookFlags, create, deps) {
+    function mountEffectImpl(fiberFlags, hookFlags, create2, deps) {
       var hook = mountWorkInProgressHook();
       currentlyRenderingFiber.flags |= fiberFlags;
-      hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, { destroy: undefined }, create, deps === undefined ? null : deps);
+      hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, { destroy: undefined }, create2, deps === undefined ? null : deps);
     }
-    function updateEffectImpl(fiberFlags, hookFlags, create, deps) {
+    function updateEffectImpl(fiberFlags, hookFlags, create2, deps) {
       var hook = updateWorkInProgressHook();
       deps = deps === undefined ? null : deps;
       var inst = hook.memoizedState.inst;
-      currentHook !== null && deps !== null && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, inst, create, deps));
+      currentHook !== null && deps !== null && areHookInputsEqual(deps, currentHook.memoizedState.deps) ? hook.memoizedState = pushSimpleEffect(hookFlags, inst, create2, deps) : (currentlyRenderingFiber.flags |= fiberFlags, hook.memoizedState = pushSimpleEffect(HasEffect | hookFlags, inst, create2, deps));
     }
-    function mountEffect(create, deps) {
-      (currentlyRenderingFiber.mode & 16) !== NoMode ? mountEffectImpl(276826112, Passive, create, deps) : mountEffectImpl(8390656, Passive, create, deps);
+    function mountEffect(create2, deps) {
+      (currentlyRenderingFiber.mode & 16) !== NoMode ? mountEffectImpl(276826112, Passive, create2, deps) : mountEffectImpl(8390656, Passive, create2, deps);
     }
     function useEffectEventImpl(payload) {
       currentlyRenderingFiber.flags |= 4;
@@ -13615,35 +15461,35 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
         return ref.impl.apply(undefined, arguments);
       };
     }
-    function mountLayoutEffect(create, deps) {
+    function mountLayoutEffect(create2, deps) {
       var fiberFlags = 4194308;
       (currentlyRenderingFiber.mode & 16) !== NoMode && (fiberFlags |= 134217728);
-      return mountEffectImpl(fiberFlags, Layout, create, deps);
+      return mountEffectImpl(fiberFlags, Layout, create2, deps);
     }
-    function imperativeHandleEffect(create, ref) {
+    function imperativeHandleEffect(create2, ref) {
       if (typeof ref === "function") {
-        create = create();
-        var refCleanup = ref(create);
+        create2 = create2();
+        var refCleanup = ref(create2);
         return function() {
           typeof refCleanup === "function" ? refCleanup() : ref(null);
         };
       }
       if (ref !== null && ref !== undefined)
-        return ref.hasOwnProperty("current") || console.error("Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(ref).join(", ") + "}"), create = create(), ref.current = create, function() {
+        return ref.hasOwnProperty("current") || console.error("Expected useImperativeHandle() first argument to either be a ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(ref).join(", ") + "}"), create2 = create2(), ref.current = create2, function() {
           ref.current = null;
         };
     }
-    function mountImperativeHandle(ref, create, deps) {
-      typeof create !== "function" && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", create !== null ? typeof create : "null");
+    function mountImperativeHandle(ref, create2, deps) {
+      typeof create2 !== "function" && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", create2 !== null ? typeof create2 : "null");
       deps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
       var fiberFlags = 4194308;
       (currentlyRenderingFiber.mode & 16) !== NoMode && (fiberFlags |= 134217728);
-      mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+      mountEffectImpl(fiberFlags, Layout, imperativeHandleEffect.bind(null, create2, ref), deps);
     }
-    function updateImperativeHandle(ref, create, deps) {
-      typeof create !== "function" && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", create !== null ? typeof create : "null");
+    function updateImperativeHandle(ref, create2, deps) {
+      typeof create2 !== "function" && console.error("Expected useImperativeHandle() second argument to be a function that creates a handle. Instead received: %s.", create2 !== null ? typeof create2 : "null");
       deps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
-      updateEffectImpl(4, Layout, imperativeHandleEffect.bind(null, create, ref), deps);
+      updateEffectImpl(4, Layout, imperativeHandleEffect.bind(null, create2, ref), deps);
     }
     function mountCallback(callback, deps) {
       mountWorkInProgressHook().memoizedState = [
@@ -13848,7 +15694,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       var args = arguments;
       typeof args[3] === "function" && console.error("State updates from the useState() and useReducer() Hooks don't support the second callback argument. To execute a side effect after rendering, declare it in the component body with useEffect().");
       args = requestUpdateLane(fiber);
-      var update = {
+      var update2 = {
         lane: args,
         revertLane: 0,
         gesture: null,
@@ -13857,7 +15703,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
         eagerState: null,
         next: null
       };
-      isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, update) : (update = enqueueConcurrentHookUpdate(fiber, queue, update, args), update !== null && (startUpdateTimerByLane(args, "dispatch()", fiber), scheduleUpdateOnFiber(update, fiber, args), entangleTransitionUpdate(update, queue, args)));
+      isRenderPhaseUpdate(fiber) ? enqueueRenderPhaseUpdate(queue, update2) : (update2 = enqueueConcurrentHookUpdate(fiber, queue, update2, args), update2 !== null && (startUpdateTimerByLane(args, "dispatch()", fiber), scheduleUpdateOnFiber(update2, fiber, args), entangleTransitionUpdate(update2, queue, args)));
     }
     function dispatchSetState(fiber, queue, action) {
       var args = arguments;
@@ -13866,7 +15712,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       dispatchSetStateInternal(fiber, queue, action, args) && startUpdateTimerByLane(args, "setState()", fiber);
     }
     function dispatchSetStateInternal(fiber, queue, action, lane) {
-      var update = {
+      var update2 = {
         lane,
         revertLane: 0,
         gesture: null,
@@ -13876,7 +15722,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
         next: null
       };
       if (isRenderPhaseUpdate(fiber))
-        enqueueRenderPhaseUpdate(queue, update);
+        enqueueRenderPhaseUpdate(queue, update2);
       else {
         var alternate = fiber.alternate;
         if (fiber.lanes === 0 && (alternate === null || alternate.lanes === 0) && (alternate = queue.lastRenderedReducer, alternate !== null)) {
@@ -13884,15 +15730,15 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
           ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
           try {
             var currentState = queue.lastRenderedState, eagerState = alternate(currentState, action);
-            update.hasEagerState = true;
-            update.eagerState = eagerState;
+            update2.hasEagerState = true;
+            update2.eagerState = eagerState;
             if (objectIs(eagerState, currentState))
-              return enqueueUpdate$1(fiber, queue, update, 0), workInProgressRoot === null && finishQueueingConcurrentUpdates(), false;
+              return enqueueUpdate$1(fiber, queue, update2, 0), workInProgressRoot === null && finishQueueingConcurrentUpdates(), false;
           } catch (error) {} finally {
             ReactSharedInternals.H = prevDispatcher;
           }
         }
-        action = enqueueConcurrentHookUpdate(fiber, queue, update, lane);
+        action = enqueueConcurrentHookUpdate(fiber, queue, update2, lane);
         if (action !== null)
           return scheduleUpdateOnFiber(action, fiber, lane), entangleTransitionUpdate(action, queue, lane), true;
       }
@@ -13920,11 +15766,11 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       var alternate = fiber.alternate;
       return fiber === currentlyRenderingFiber || alternate !== null && alternate === currentlyRenderingFiber;
     }
-    function enqueueRenderPhaseUpdate(queue, update) {
+    function enqueueRenderPhaseUpdate(queue, update2) {
       didScheduleRenderPhaseUpdateDuringThisPass = didScheduleRenderPhaseUpdate = true;
       var pending = queue.pending;
-      pending === null ? update.next = update : (update.next = pending.next, pending.next = update);
-      queue.pending = update;
+      pending === null ? update2.next = update2 : (update2.next = pending.next, pending.next = update2);
+      queue.pending = update2;
     }
     function entangleTransitionUpdate(root, queue, lane) {
       if ((lane & 4194048) !== 0) {
@@ -13952,7 +15798,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
         }
       }
       partialState === undefined && (ctor = getComponentNameFromType(ctor) || "Component", didWarnAboutUndefinedDerivedState.has(ctor) || (didWarnAboutUndefinedDerivedState.add(ctor), console.error("%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. You have returned undefined.", ctor)));
-      prevState = partialState === null || partialState === undefined ? prevState : assign({}, prevState, partialState);
+      prevState = partialState === null || partialState === undefined ? prevState : assign2({}, prevState, partialState);
       workInProgress2.memoizedState = prevState;
       workInProgress2.lanes === 0 && (workInProgress2.updateQueue.baseState = prevState);
     }
@@ -13987,7 +15833,7 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
           propName !== "ref" && (newProps[propName] = baseProps[propName]);
       }
       if (Component = Component.defaultProps) {
-        newProps === baseProps && (newProps = assign({}, newProps));
+        newProps === baseProps && (newProps = assign2({}, newProps));
         for (var _propName in Component)
           newProps[_propName] === undefined && (newProps[_propName] = Component[_propName]);
       }
@@ -14039,20 +15885,20 @@ Incoming: %s`, currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + next
       lane.tag = CaptureUpdate;
       return lane;
     }
-    function initializeClassErrorUpdate(update, root, fiber, errorInfo) {
+    function initializeClassErrorUpdate(update2, root, fiber, errorInfo) {
       var getDerivedStateFromError = fiber.type.getDerivedStateFromError;
       if (typeof getDerivedStateFromError === "function") {
         var error = errorInfo.value;
-        update.payload = function() {
+        update2.payload = function() {
           return getDerivedStateFromError(error);
         };
-        update.callback = function() {
+        update2.callback = function() {
           markFailedErrorBoundaryForHotReloading(fiber);
           runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
         };
       }
       var inst = fiber.stateNode;
-      inst !== null && typeof inst.componentDidCatch === "function" && (update.callback = function() {
+      inst !== null && typeof inst.componentDidCatch === "function" && (update2.callback = function() {
         markFailedErrorBoundaryForHotReloading(fiber);
         runWithFiberInDEV(errorInfo.source, logCaughtError, root, fiber, errorInfo);
         typeof getDerivedStateFromError !== "function" && (legacyErrorBoundariesThatAlreadyFailed === null ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this));
@@ -14613,17 +16459,17 @@ https://react.dev/link/unsafe-component-lifecycles`, _instance, newApiName, stat
       alternate !== null && (alternate.lanes |= renderLanes2);
       scheduleContextWorkOnParentPath(fiber.return, renderLanes2, propagationRoot);
     }
-    function initSuspenseListRenderState(workInProgress2, isBackwards, tail, lastContentRow, tailMode, treeForkCount2) {
+    function initSuspenseListRenderState(workInProgress2, isBackwards, tail2, lastContentRow, tailMode, treeForkCount2) {
       var renderState = workInProgress2.memoizedState;
       renderState === null ? workInProgress2.memoizedState = {
         isBackwards,
         rendering: null,
         renderingStartTime: 0,
         last: lastContentRow,
-        tail,
+        tail: tail2,
         tailMode,
         treeForkCount: treeForkCount2
-      } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
+      } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.renderingStartTime = 0, renderState.last = lastContentRow, renderState.tail = tail2, renderState.tailMode = tailMode, renderState.treeForkCount = treeForkCount2);
     }
     function updateSuspenseListComponent(current2, workInProgress2, renderLanes2) {
       var nextProps = workInProgress2.pendingProps, revealOrder = nextProps.revealOrder, tailMode = nextProps.tail, newChildren = nextProps.children, suspenseContext = suspenseStackCursor.current;
@@ -15740,21 +17586,21 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
             return fiber.stateNode;
         }
     }
-    function insertOrAppendPlacementNodeIntoContainer(node, before, parent) {
+    function insertOrAppendPlacementNodeIntoContainer(node, before2, parent) {
       var tag = node.tag;
       if (tag === 5 || tag === 6)
-        node = node.stateNode, before ? insertInContainerBefore(parent, node, before) : appendChildToContainer(parent, node);
-      else if (tag !== 4 && (supportsSingletons && tag === 27 && isSingletonScope(node.type) && (parent = node.stateNode, before = null), node = node.child, node !== null))
-        for (insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;node !== null; )
-          insertOrAppendPlacementNodeIntoContainer(node, before, parent), node = node.sibling;
+        node = node.stateNode, before2 ? insertInContainerBefore(parent, node, before2) : appendChildToContainer(parent, node);
+      else if (tag !== 4 && (supportsSingletons && tag === 27 && isSingletonScope(node.type) && (parent = node.stateNode, before2 = null), node = node.child, node !== null))
+        for (insertOrAppendPlacementNodeIntoContainer(node, before2, parent), node = node.sibling;node !== null; )
+          insertOrAppendPlacementNodeIntoContainer(node, before2, parent), node = node.sibling;
     }
-    function insertOrAppendPlacementNode(node, before, parent) {
+    function insertOrAppendPlacementNode(node, before2, parent) {
       var tag = node.tag;
       if (tag === 5 || tag === 6)
-        node = node.stateNode, before ? insertBefore(parent, node, before) : appendChild(parent, node);
+        node = node.stateNode, before2 ? insertBefore(parent, node, before2) : appendChild(parent, node);
       else if (tag !== 4 && (supportsSingletons && tag === 27 && isSingletonScope(node.type) && (parent = node.stateNode), node = node.child, node !== null))
-        for (insertOrAppendPlacementNode(node, before, parent), node = node.sibling;node !== null; )
-          insertOrAppendPlacementNode(node, before, parent), node = node.sibling;
+        for (insertOrAppendPlacementNode(node, before2, parent), node = node.sibling;node !== null; )
+          insertOrAppendPlacementNode(node, before2, parent), node = node.sibling;
     }
     function commitPlacement(finishedWork) {
       for (var hostParentFiber, parentFiber = finishedWork.return;parentFiber !== null; ) {
@@ -17029,7 +18875,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
         if (startTime === RootInProgress) {
           workInProgressRootIsPrerendering && !forceSync && markRootSuspended(root, lanes, 0, false);
           lanes = workInProgressSuspendedReason;
-          yieldStartTime = now();
+          yieldStartTime = now2();
           yieldReason = lanes;
           break;
         } else {
@@ -17218,7 +19064,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
     function prepareFreshStack(root, lanes) {
       supportsUserTiming && (console.timeStamp("Blocking Track", 0.003, 0.003, "Blocking", "Scheduler \u269B", "primary-light"), console.timeStamp("Transition Track", 0.003, 0.003, "Transition", "Scheduler \u269B", "primary-light"), console.timeStamp("Suspense Track", 0.003, 0.003, "Suspense", "Scheduler \u269B", "primary-light"), console.timeStamp("Idle Track", 0.003, 0.003, "Idle", "Scheduler \u269B", "primary-light"));
       var previousRenderStartTime = renderStartTime;
-      renderStartTime = now();
+      renderStartTime = now2();
       if (workInProgressRootRenderLanes !== 0 && 0 < previousRenderStartTime) {
         setCurrentTrackFromLanes(workInProgressRootRenderLanes);
         if (workInProgressRootExitStatus === RootSuspended || workInProgressRootExitStatus === RootSuspendedWithDelay)
@@ -17273,7 +19119,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
         blockingSuspendedTime = -1.1;
         blockingEventRepeatTime = blockingEventTime;
         blockingEventTime = -1.1;
-        blockingClampTime = now();
+        blockingClampTime = now2();
       }
       (lanes & 4194048) !== 0 && (workInProgressUpdateTask = transitionUpdateTask, debugTask = 0 <= transitionStartTime && transitionStartTime < transitionClampTime ? transitionClampTime : transitionStartTime, previousRenderStartTime = 0 <= transitionUpdateTime && transitionUpdateTime < transitionClampTime ? transitionClampTime : transitionUpdateTime, endTime = 0 <= transitionEventTime && transitionEventTime < transitionClampTime ? transitionClampTime : transitionEventTime, color = 0 <= endTime ? endTime : 0 <= previousRenderStartTime ? previousRenderStartTime : renderStartTime, 0 <= transitionSuspendedTime && (setCurrentTrackFromLanes(256), logSuspendedWithDelayPhase(transitionSuspendedTime, color, lanes, workInProgressUpdateTask)), isPingedUpdate = endTime, eventTime = transitionEventType, eventType = 0 < transitionEventRepeatTime, eventIsRepeat = transitionUpdateType === 2, color = renderStartTime, endTime = transitionUpdateTask, label = transitionUpdateMethodName, isSpawnedUpdate = transitionUpdateComponentName, supportsUserTiming && (currentTrack = "Transition", 0 < previousRenderStartTime ? previousRenderStartTime > color && (previousRenderStartTime = color) : previousRenderStartTime = color, 0 < debugTask ? debugTask > previousRenderStartTime && (debugTask = previousRenderStartTime) : debugTask = previousRenderStartTime, 0 < isPingedUpdate ? isPingedUpdate > debugTask && (isPingedUpdate = debugTask) : isPingedUpdate = debugTask, debugTask > isPingedUpdate && eventTime !== null && (color$jscomp$0 = eventType ? "secondary-light" : "warning", endTime ? endTime.run(console.timeStamp.bind(console, eventType ? "Consecutive" : "Event: " + eventTime, isPingedUpdate, debugTask, currentTrack, "Scheduler \u269B", color$jscomp$0)) : console.timeStamp(eventType ? "Consecutive" : "Event: " + eventTime, isPingedUpdate, debugTask, currentTrack, "Scheduler \u269B", color$jscomp$0)), previousRenderStartTime > debugTask && (endTime ? endTime.run(console.timeStamp.bind(console, "Action", debugTask, previousRenderStartTime, currentTrack, "Scheduler \u269B", "primary-dark")) : console.timeStamp("Action", debugTask, previousRenderStartTime, currentTrack, "Scheduler \u269B", "primary-dark")), color > previousRenderStartTime && (debugTask = eventIsRepeat ? "Promise Resolved" : 5 < color - previousRenderStartTime ? "Update Blocked" : "Update", isPingedUpdate = [], isSpawnedUpdate != null && isPingedUpdate.push(["Component name", isSpawnedUpdate]), label != null && isPingedUpdate.push(["Method name", label]), previousRenderStartTime = {
         start: previousRenderStartTime,
@@ -17286,7 +19132,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
             color: "primary-light"
           }
         }
-      }, endTime ? endTime.run(performance.measure.bind(performance, debugTask, previousRenderStartTime)) : performance.measure(debugTask, previousRenderStartTime))), transitionUpdateTime = transitionStartTime = -1.1, transitionUpdateType = 0, transitionSuspendedTime = -1.1, transitionEventRepeatTime = transitionEventTime, transitionEventTime = -1.1, transitionClampTime = now());
+      }, endTime ? endTime.run(performance.measure.bind(performance, debugTask, previousRenderStartTime)) : performance.measure(debugTask, previousRenderStartTime))), transitionUpdateTime = transitionStartTime = -1.1, transitionUpdateType = 0, transitionSuspendedTime = -1.1, transitionEventRepeatTime = transitionEventTime, transitionEventTime = -1.1, transitionClampTime = now2());
       previousRenderStartTime = root.timeoutHandle;
       previousRenderStartTime !== noTimeout && (root.timeoutHandle = noTimeout, cancelTimeout(previousRenderStartTime));
       previousRenderStartTime = root.cancelPendingCommit;
@@ -17671,7 +19517,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
           return null;
         })) : (root.callbackNode = null, root.callbackPriority = 0);
         commitErrors = null;
-        commitStartTime = now();
+        commitStartTime = now2();
         suspendedCommitReason !== null && logSuspendedCommitPhase(completedRenderEndTime, commitStartTime, suspendedCommitReason, workInProgressUpdateTask);
         recoverableErrors = (finishedWork.flags & 13878) !== 0;
         if ((finishedWork.subtreeFlags & 13878) !== 0 || recoverableErrors) {
@@ -17719,7 +19565,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
         pendingEffectsStatus = NO_PENDING_EFFECTS;
         var suspendedViewTransitionReason = pendingSuspendedViewTransitionReason;
         if (suspendedViewTransitionReason !== null) {
-          commitStartTime = now();
+          commitStartTime = now2();
           var startTime = commitEndTime, endTime = commitStartTime;
           !supportsUserTiming || endTime <= startTime || (animatingTask ? animatingTask.run(console.timeStamp.bind(console, suspendedViewTransitionReason, startTime, endTime, currentTrack, "Scheduler \u269B", "secondary-light")) : console.timeStamp(suspendedViewTransitionReason, startTime, endTime, currentTrack, "Scheduler \u269B", "secondary-light"));
         }
@@ -17742,7 +19588,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
         }
         suspendedViewTransitionReason = pendingEffectsRenderEndTime;
         startTime = pendingSuspendedCommitReason;
-        commitEndTime = now();
+        commitEndTime = now2();
         suspendedViewTransitionReason = startTime === null ? suspendedViewTransitionReason : commitStartTime;
         startTime = commitEndTime;
         endTime = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
@@ -17755,7 +19601,7 @@ Learn more about data fetching with Hooks: https://react.dev/link/hooks-data-fet
       if (pendingEffectsStatus === PENDING_SPAWNED_WORK || pendingEffectsStatus === PENDING_AFTER_MUTATION_PHASE) {
         if (pendingEffectsStatus === PENDING_SPAWNED_WORK) {
           var startViewTransitionStartTime = commitEndTime;
-          commitEndTime = now();
+          commitEndTime = now2();
           var endTime = commitEndTime, abortedViewTransition = pendingDelayedCommitReason === ABORTED_VIEW_TRANSITION_COMMIT;
           !supportsUserTiming || endTime <= startViewTransitionStartTime || (animatingTask ? animatingTask.run(console.timeStamp.bind(console, abortedViewTransition ? "Interrupted View Transition" : "Starting Animation", startViewTransitionStartTime, endTime, currentTrack, "Scheduler \u269B", abortedViewTransition ? "error" : "secondary-light")) : console.timeStamp(abortedViewTransition ? "Interrupted View Transition" : "Starting Animation", startViewTransitionStartTime, endTime, currentTrack, "Scheduler \u269B", abortedViewTransition ? " error" : "secondary-light"));
           pendingDelayedCommitReason !== ABORTED_VIEW_TRANSITION_COMMIT && (pendingDelayedCommitReason = ANIMATION_STARTED_COMMIT);
@@ -17960,7 +19806,7 @@ Error message:
       pingCache !== null && pingCache.delete(wakeable);
       root.pingedLanes |= root.suspendedLanes & pingedLanes;
       root.warmLanes &= ~pingedLanes;
-      (pingedLanes & 127) !== 0 ? 0 > blockingUpdateTime && (blockingClampTime = blockingUpdateTime = now(), blockingUpdateTask = createTask("Promise Resolved"), blockingUpdateType = 2) : (pingedLanes & 4194048) !== 0 && 0 > transitionUpdateTime && (transitionClampTime = transitionUpdateTime = now(), transitionUpdateTask = createTask("Promise Resolved"), transitionUpdateType = 2);
+      (pingedLanes & 127) !== 0 ? 0 > blockingUpdateTime && (blockingClampTime = blockingUpdateTime = now2(), blockingUpdateTask = createTask("Promise Resolved"), blockingUpdateType = 2) : (pingedLanes & 4194048) !== 0 && 0 > transitionUpdateTime && (transitionClampTime = transitionUpdateTime = now2(), transitionUpdateTask = createTask("Promise Resolved"), transitionUpdateType = 2);
       isConcurrentActEnvironment() && ReactSharedInternals.actQueue === null && console.error(`A suspended resource finished loading inside a test, but the event was not wrapped in act(...).
 
 When testing, code that resolves suspended data should be wrapped into act(...):
@@ -18395,7 +20241,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
       return current;
     }
     var exports2 = {};
-    var assign = Object.assign, REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy");
+    var assign2 = Object.assign, REACT_LEGACY_ELEMENT_TYPE = Symbol.for("react.element"), REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"), REACT_PORTAL_TYPE = Symbol.for("react.portal"), REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"), REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"), REACT_PROFILER_TYPE = Symbol.for("react.profiler"), REACT_CONSUMER_TYPE = Symbol.for("react.consumer"), REACT_CONTEXT_TYPE = Symbol.for("react.context"), REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"), REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"), REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"), REACT_MEMO_TYPE = Symbol.for("react.memo"), REACT_LAZY_TYPE = Symbol.for("react.lazy");
     Symbol.for("react.scope");
     var REACT_ACTIVITY_TYPE = Symbol.for("react.activity");
     Symbol.for("react.legacy_hidden");
@@ -18513,14 +20359,14 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
       _threadCount: 0,
       _currentRenderer: null,
       _currentRenderer2: null
-    }, now = Scheduler.unstable_now, createTask = console.createTask ? console.createTask : function() {
+    }, now2 = Scheduler.unstable_now, createTask = console.createTask ? console.createTask : function() {
       return null;
     }, renderStartTime = -0, commitStartTime = -0, commitEndTime = -0, commitErrors = null, profilerStartTime = -1.1, profilerEffectDuration = -0, componentEffectDuration = -0, componentEffectStartTime = -1.1, componentEffectEndTime = -1.1, componentEffectErrors = null, componentEffectSpawnedUpdate = false, blockingClampTime = -0, blockingUpdateTime = -1.1, blockingUpdateTask = null, blockingUpdateType = 0, blockingUpdateMethodName = null, blockingUpdateComponentName = null, blockingEventTime = -1.1, blockingEventType = null, blockingEventRepeatTime = -1.1, blockingSuspendedTime = -1.1, transitionClampTime = -0, transitionStartTime = -1.1, transitionUpdateTime = -1.1, transitionUpdateType = 0, transitionUpdateTask = null, transitionUpdateMethodName = null, transitionUpdateComponentName = null, transitionEventTime = -1.1, transitionEventType = null, transitionEventRepeatTime = -1.1, transitionSuspendedTime = -1.1, animatingTask = null, yieldReason = 0, yieldStartTime = -1.1, currentUpdateIsNested = false, nestedUpdateScheduled = false, firstScheduledRoot = null, lastScheduledRoot = null, didScheduleMicrotask = false, didScheduleMicrotask_act = false, mightHavePendingSyncWork = false, isFlushingWork = false, currentEventTransitionLane = 0, fakeActCallbackNode$1 = {}, currentEntangledListeners = null, currentEntangledPendingCount = 0, currentEntangledLane = 0, currentEntangledActionThenable = null, prevOnStartTransitionFinish = ReactSharedInternals.S;
     ReactSharedInternals.S = function(transition, returnValue) {
       globalMostRecentTransitionTime = now$1();
       if (typeof returnValue === "object" && returnValue !== null && typeof returnValue.then === "function") {
         if (0 > transitionStartTime && 0 > transitionUpdateTime) {
-          transitionStartTime = now();
+          transitionStartTime = now2();
           var newEventTime = resolveEventTimeStamp(), newEventType = resolveEventType();
           if (newEventTime !== transitionEventRepeatTime || newEventType !== transitionEventType)
             transitionEventRepeatTime = -1.1;
@@ -18701,10 +20547,10 @@ Learn more about this warning here: https://react.dev/link/legacy-context`, sort
       }
     }, callComponentWillUnmountInDEV = callComponentWillUnmount.react_stack_bottom_frame.bind(callComponentWillUnmount), callCreate = {
       react_stack_bottom_frame: function(effect) {
-        var create = effect.create;
+        var create2 = effect.create;
         effect = effect.inst;
-        create = create();
-        return effect.destroy = create;
+        create2 = create2();
+        return effect.destroy = create2;
       }
     }, callCreateInDEV = callCreate.react_stack_bottom_frame.bind(callCreate), callDestroy = {
       react_stack_bottom_frame: function(current2, nearestMountedAncestor, destroy) {
@@ -18804,38 +20650,38 @@ Check the top-level render call using <` + componentName2 + ">.");
         mountHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         mountHookTypesDev();
         checkDepsAreArrayDev(deps);
-        return mountEffect(create, deps);
+        return mountEffect(create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         mountHookTypesDev();
         checkDepsAreArrayDev(deps);
-        return mountImperativeHandle(ref, create, deps);
+        return mountImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         mountHookTypesDev();
         checkDepsAreArrayDev(deps);
-        mountEffectImpl(4, Insertion, create, deps);
+        mountEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         mountHookTypesDev();
         checkDepsAreArrayDev(deps);
-        return mountLayoutEffect(create, deps);
+        return mountLayoutEffect(create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         mountHookTypesDev();
         checkDepsAreArrayDev(deps);
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
         try {
-          return mountMemo(create, deps);
+          return mountMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -18935,33 +20781,33 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         updateHookTypesDev();
-        return mountEffect(create, deps);
+        return mountEffect(create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         updateHookTypesDev();
-        return mountImperativeHandle(ref, create, deps);
+        return mountImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         updateHookTypesDev();
-        mountEffectImpl(4, Insertion, create, deps);
+        mountEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         updateHookTypesDev();
-        return mountLayoutEffect(create, deps);
+        return mountLayoutEffect(create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         updateHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
         try {
-          return mountMemo(create, deps);
+          return mountMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19061,33 +20907,33 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         updateHookTypesDev();
-        updateEffectImpl(2048, Passive, create, deps);
+        updateEffectImpl(2048, Passive, create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         updateHookTypesDev();
-        return updateImperativeHandle(ref, create, deps);
+        return updateImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         updateHookTypesDev();
-        return updateEffectImpl(4, Insertion, create, deps);
+        return updateEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         updateHookTypesDev();
-        return updateEffectImpl(4, Layout, create, deps);
+        return updateEffectImpl(4, Layout, create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         updateHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
         try {
-          return updateMemo(create, deps);
+          return updateMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19187,33 +21033,33 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         updateHookTypesDev();
-        updateEffectImpl(2048, Passive, create, deps);
+        updateEffectImpl(2048, Passive, create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         updateHookTypesDev();
-        return updateImperativeHandle(ref, create, deps);
+        return updateImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         updateHookTypesDev();
-        return updateEffectImpl(4, Insertion, create, deps);
+        return updateEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         updateHookTypesDev();
-        return updateEffectImpl(4, Layout, create, deps);
+        return updateEffectImpl(4, Layout, create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         updateHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnRerenderInDEV;
         try {
-          return updateMemo(create, deps);
+          return updateMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19319,38 +21165,38 @@ Check the top-level render call using <` + componentName2 + ">.");
         mountHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         warnInvalidHookAccess();
         mountHookTypesDev();
-        return mountEffect(create, deps);
+        return mountEffect(create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         warnInvalidHookAccess();
         mountHookTypesDev();
-        return mountImperativeHandle(ref, create, deps);
+        return mountImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         warnInvalidHookAccess();
         mountHookTypesDev();
-        mountEffectImpl(4, Insertion, create, deps);
+        mountEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         warnInvalidHookAccess();
         mountHookTypesDev();
-        return mountLayoutEffect(create, deps);
+        return mountLayoutEffect(create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         warnInvalidHookAccess();
         mountHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnMountInDEV;
         try {
-          return mountMemo(create, deps);
+          return mountMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19432,9 +21278,9 @@ Check the top-level render call using <` + componentName2 + ">.");
         mountHookTypesDev();
         return mountOptimistic(passthrough);
       },
-      useMemoCache: function(size) {
+      useMemoCache: function(size2) {
         warnInvalidHookAccess();
-        return useMemoCache(size);
+        return useMemoCache(size2);
       },
       useHostTransitionStatus,
       useCacheRefresh: function() {
@@ -19470,38 +21316,38 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        updateEffectImpl(2048, Passive, create, deps);
+        updateEffectImpl(2048, Passive, create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateImperativeHandle(ref, create, deps);
+        return updateImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateEffectImpl(4, Insertion, create, deps);
+        return updateEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateEffectImpl(4, Layout, create, deps);
+        return updateEffectImpl(4, Layout, create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         warnInvalidHookAccess();
         updateHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
         try {
-          return updateMemo(create, deps);
+          return updateMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19583,9 +21429,9 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return updateOptimistic(passthrough, reducer);
       },
-      useMemoCache: function(size) {
+      useMemoCache: function(size2) {
         warnInvalidHookAccess();
-        return useMemoCache(size);
+        return useMemoCache(size2);
       },
       useHostTransitionStatus,
       useCacheRefresh: function() {
@@ -19621,38 +21467,38 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return readContext(context);
       },
-      useEffect: function(create, deps) {
+      useEffect: function(create2, deps) {
         currentHookNameInDev = "useEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        updateEffectImpl(2048, Passive, create, deps);
+        updateEffectImpl(2048, Passive, create2, deps);
       },
-      useImperativeHandle: function(ref, create, deps) {
+      useImperativeHandle: function(ref, create2, deps) {
         currentHookNameInDev = "useImperativeHandle";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateImperativeHandle(ref, create, deps);
+        return updateImperativeHandle(ref, create2, deps);
       },
-      useInsertionEffect: function(create, deps) {
+      useInsertionEffect: function(create2, deps) {
         currentHookNameInDev = "useInsertionEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateEffectImpl(4, Insertion, create, deps);
+        return updateEffectImpl(4, Insertion, create2, deps);
       },
-      useLayoutEffect: function(create, deps) {
+      useLayoutEffect: function(create2, deps) {
         currentHookNameInDev = "useLayoutEffect";
         warnInvalidHookAccess();
         updateHookTypesDev();
-        return updateEffectImpl(4, Layout, create, deps);
+        return updateEffectImpl(4, Layout, create2, deps);
       },
-      useMemo: function(create, deps) {
+      useMemo: function(create2, deps) {
         currentHookNameInDev = "useMemo";
         warnInvalidHookAccess();
         updateHookTypesDev();
         var prevDispatcher = ReactSharedInternals.H;
         ReactSharedInternals.H = InvalidNestedHooksDispatcherOnUpdateInDEV;
         try {
-          return updateMemo(create, deps);
+          return updateMemo(create2, deps);
         } finally {
           ReactSharedInternals.H = prevDispatcher;
         }
@@ -19734,9 +21580,9 @@ Check the top-level render call using <` + componentName2 + ">.");
         updateHookTypesDev();
         return rerenderOptimistic(passthrough, reducer);
       },
-      useMemoCache: function(size) {
+      useMemoCache: function(size2) {
         warnInvalidHookAccess();
-        return useMemoCache(size);
+        return useMemoCache(size2);
       },
       useHostTransitionStatus,
       useCacheRefresh: function() {
@@ -19766,27 +21612,27 @@ Check the top-level render call using <` + componentName2 + ">.");
     var classComponentUpdater = {
       enqueueSetState: function(inst, payload, callback) {
         inst = inst._reactInternals;
-        var lane = requestUpdateLane(inst), update = createUpdate(lane);
-        update.payload = payload;
-        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update.callback = callback);
-        payload = enqueueUpdate(inst, update, lane);
+        var lane = requestUpdateLane(inst), update2 = createUpdate(lane);
+        update2.payload = payload;
+        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update2.callback = callback);
+        payload = enqueueUpdate(inst, update2, lane);
         payload !== null && (startUpdateTimerByLane(lane, "this.setState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
       },
       enqueueReplaceState: function(inst, payload, callback) {
         inst = inst._reactInternals;
-        var lane = requestUpdateLane(inst), update = createUpdate(lane);
-        update.tag = ReplaceState;
-        update.payload = payload;
-        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update.callback = callback);
-        payload = enqueueUpdate(inst, update, lane);
+        var lane = requestUpdateLane(inst), update2 = createUpdate(lane);
+        update2.tag = ReplaceState;
+        update2.payload = payload;
+        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update2.callback = callback);
+        payload = enqueueUpdate(inst, update2, lane);
         payload !== null && (startUpdateTimerByLane(lane, "this.replaceState()", inst), scheduleUpdateOnFiber(payload, inst, lane), entangleTransitions(payload, inst, lane));
       },
       enqueueForceUpdate: function(inst, callback) {
         inst = inst._reactInternals;
-        var lane = requestUpdateLane(inst), update = createUpdate(lane);
-        update.tag = ForceUpdate;
-        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update.callback = callback);
-        callback = enqueueUpdate(inst, update, lane);
+        var lane = requestUpdateLane(inst), update2 = createUpdate(lane);
+        update2.tag = ForceUpdate;
+        callback !== undefined && callback !== null && (warnOnInvalidCallback(callback), update2.callback = callback);
+        callback = enqueueUpdate(inst, update2, lane);
         callback !== null && (startUpdateTimerByLane(lane, "this.forceUpdate()", inst), scheduleUpdateOnFiber(callback, inst, lane), entangleTransitions(callback, inst, lane));
       }
     }, componentName = null, errorBoundaryName = null, SelectiveHydrationException = Error("This is not a real error. It's an implementation detail of React's selective hydration feature. If this leaks into userspace, it's a bug in React. Please file an issue."), didReceiveUpdate = false;
@@ -19841,15 +21687,15 @@ Check the top-level render call using <` + componentName2 + ">.");
     var overrideHookState = null, overrideHookStateDeletePath = null, overrideHookStateRenamePath = null, overrideProps = null, overridePropsDeletePath = null, overridePropsRenamePath = null, scheduleUpdate = null, scheduleRetry = null, setErrorHandler = null, setSuspenseHandler = null;
     overrideHookState = function(fiber, id, path11, value) {
       id = findHook(fiber, id);
-      id !== null && (path11 = copyWithSetImpl(id.memoizedState, path11, 0, value), id.memoizedState = path11, id.baseState = path11, fiber.memoizedProps = assign({}, fiber.memoizedProps), path11 = enqueueConcurrentRenderForLane(fiber, 2), path11 !== null && scheduleUpdateOnFiber(path11, fiber, 2));
+      id !== null && (path11 = copyWithSetImpl(id.memoizedState, path11, 0, value), id.memoizedState = path11, id.baseState = path11, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path11 = enqueueConcurrentRenderForLane(fiber, 2), path11 !== null && scheduleUpdateOnFiber(path11, fiber, 2));
     };
     overrideHookStateDeletePath = function(fiber, id, path11) {
       id = findHook(fiber, id);
-      id !== null && (path11 = copyWithDeleteImpl(id.memoizedState, path11, 0), id.memoizedState = path11, id.baseState = path11, fiber.memoizedProps = assign({}, fiber.memoizedProps), path11 = enqueueConcurrentRenderForLane(fiber, 2), path11 !== null && scheduleUpdateOnFiber(path11, fiber, 2));
+      id !== null && (path11 = copyWithDeleteImpl(id.memoizedState, path11, 0), id.memoizedState = path11, id.baseState = path11, fiber.memoizedProps = assign2({}, fiber.memoizedProps), path11 = enqueueConcurrentRenderForLane(fiber, 2), path11 !== null && scheduleUpdateOnFiber(path11, fiber, 2));
     };
     overrideHookStateRenamePath = function(fiber, id, oldPath, newPath) {
       id = findHook(fiber, id);
-      id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
+      id !== null && (oldPath = copyWithRename(id.memoizedState, oldPath, newPath), id.memoizedState = oldPath, id.baseState = oldPath, fiber.memoizedProps = assign2({}, fiber.memoizedProps), oldPath = enqueueConcurrentRenderForLane(fiber, 2), oldPath !== null && scheduleUpdateOnFiber(oldPath, fiber, 2));
     };
     overrideProps = function(fiber, path11, value) {
       fiber.pendingProps = copyWithSetImpl(fiber.memoizedProps, path11, 0, value);
@@ -20210,7 +22056,7 @@ No matching component was found for:
         throw Error("Expected the form instance to be a HostComponent. This is a bug in React.");
       var queue = ensureFormComponentIsStateful(formFiber).queue;
       startHostActionTimer(formFiber);
-      startTransition(formFiber, queue, pendingState, NotPendingTransition, action === null ? noop : function() {
+      startTransition(formFiber, queue, pendingState, NotPendingTransition, action === null ? noop2 : function() {
         ReactSharedInternals.T === null && console.error("requestFormReset was called outside a transition or action. To fix, move to an action, or wrap with startTransition.");
         var stateHook = ensureFormComponentIsStateful(formFiber);
         stateHook.next === null && (stateHook = formFiber.alternate.memoizedState);
@@ -20491,7 +22337,7 @@ var require_stack_utils = __commonJS((exports, module) => {
       }
       let outdent = false;
       let lastNonAtLine = null;
-      const result = [];
+      const result2 = [];
       stack.forEach((st) => {
         st = st.replace(/\\/g, "/");
         if (this._internals.some((internal) => internal.test(st))) {
@@ -20510,17 +22356,17 @@ var require_stack_utils = __commonJS((exports, module) => {
         if (st) {
           if (isAtLine) {
             if (lastNonAtLine) {
-              result.push(lastNonAtLine);
+              result2.push(lastNonAtLine);
               lastNonAtLine = null;
             }
-            result.push(st);
+            result2.push(st);
           } else {
             outdent = true;
             lastNonAtLine = st;
           }
         }
       });
-      return result.map((line) => `${indent}${line}
+      return result2.map((line) => `${indent}${line}
 `).join("");
     }
     captureString(limit, fn = this.captureString) {
@@ -20614,7 +22460,7 @@ var require_stack_utils = __commonJS((exports, module) => {
       const col = match[9];
       const native = match[10] === "native";
       const closeParen = match[11] === ")";
-      let method;
+      let method2;
       const res = {};
       if (lnum) {
         res.line = Number(lnum);
@@ -20630,10 +22476,10 @@ var require_stack_utils = __commonJS((exports, module) => {
           } else if (file.charAt(i) === "(" && file.charAt(i - 1) === " ") {
             closes--;
             if (closes === -1 && file.charAt(i - 1) === " ") {
-              const before = file.slice(0, i - 1);
-              const after = file.slice(i + 1);
-              file = after;
-              fname += ` (${before}`;
+              const before2 = file.slice(0, i - 1);
+              const after2 = file.slice(i + 1);
+              file = after2;
+              fname += ` (${before2}`;
               break;
             }
           }
@@ -20643,7 +22489,7 @@ var require_stack_utils = __commonJS((exports, module) => {
         const methodMatch = fname.match(methodRe);
         if (methodMatch) {
           fname = methodMatch[1];
-          method = methodMatch[2];
+          method2 = methodMatch[2];
         }
       }
       setFile(res, file, this._cwd);
@@ -20665,19 +22511,19 @@ var require_stack_utils = __commonJS((exports, module) => {
       if (fname) {
         res.function = fname;
       }
-      if (method && fname !== method) {
-        res.method = method;
+      if (method2 && fname !== method2) {
+        res.method = method2;
       }
       return res;
     }
   }
-  function setFile(result, filename, cwd2) {
+  function setFile(result2, filename, cwd2) {
     if (filename) {
       filename = filename.replace(/\\/g, "/");
       if (filename.startsWith(`${cwd2}/`)) {
         filename = filename.slice(cwd2.length + 1);
       }
-      result.file = filename;
+      result2.file = filename;
     }
   }
   function ignoredPackagesRegExp(ignoredPackages) {
@@ -22497,16 +24343,16 @@ var require_react_jsx_dev_runtime_development = __commonJS((exports) => {
           validateChildKeys(children);
       if (hasOwnProperty.call(config, "key")) {
         children = getComponentNameFromType(type);
-        var keys = Object.keys(config).filter(function(k) {
+        var keys2 = Object.keys(config).filter(function(k) {
           return k !== "key";
         });
-        isStaticChildren = 0 < keys.length ? "{key: someKey, " + keys.join(": ..., ") + ": ...}" : "{key: someKey}";
-        didWarnAboutKeySpread[children + isStaticChildren] || (keys = 0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}", console.error(`A props object containing a "key" prop is being spread into JSX:
+        isStaticChildren = 0 < keys2.length ? "{key: someKey, " + keys2.join(": ..., ") + ": ...}" : "{key: someKey}";
+        didWarnAboutKeySpread[children + isStaticChildren] || (keys2 = 0 < keys2.length ? "{" + keys2.join(": ..., ") + ": ...}" : "{}", console.error(`A props object containing a "key" prop is being spread into JSX:
   let props = %s;
   <%s {...props} />
 React keys must be passed directly to JSX without using spread:
   let props = %s;
-  <%s key={someKey} {...props} />`, isStaticChildren, children, keys, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
+  <%s key={someKey} {...props} />`, isStaticChildren, children, keys2, children), didWarnAboutKeySpread[children + isStaticChildren] = true);
       }
       children = null;
       maybeKey !== undefined && (checkKeyStringCoercion(maybeKey), children = "" + maybeKey);
@@ -22549,8 +24395,9 @@ React keys must be passed directly to JSX without using spread:
 
 // node_modules/react/jsx-dev-runtime.js
 var require_jsx_dev_runtime = __commonJS((exports, module) => {
+  var react_jsx_dev_runtime_development = __toESM(require_react_jsx_dev_runtime_development());
   if (false) {} else {
-    module.exports = require_react_jsx_dev_runtime_development();
+    module.exports = react_jsx_dev_runtime_development;
   }
 });
 
@@ -22574,7 +24421,7 @@ var {
 import figlet from "figlet";
 
 // src/version.ts
-var CLI_VERSION = "2.3.2";
+var CLI_VERSION = "2.4.1";
 
 // src/commands/build/index.ts
 var import_fs_extra4 = __toESM(require_lib(), 1);
@@ -23152,11 +24999,14 @@ async function logWorkerMain(level, ...args) {
     return;
   }
   const chunks = [];
-  chunks.push(`[${new Date().toISOString()}]${level !== false ? ` [${level}]` : ""} `);
+  const prefix = `[${new Date().toISOString()}]${level !== false ? ` [${level}]` : ""} `;
+  chunks.push(prefix);
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (typeof arg === "string") {
-      chunks.push(stripVTControlCharacters(arg));
+      chunks.push(stripVTControlCharacters(arg).replaceAll(`
+`, `
+${" ".repeat(prefix.length)}`));
     } else if (Buffer.isBuffer(arg) || arg instanceof Uint8Array) {
       chunks.push(arg);
     } else if (arg instanceof ArrayBuffer) {
@@ -23164,7 +25014,9 @@ async function logWorkerMain(level, ...args) {
     } else if (arg instanceof Blob) {
       chunks.push(new Uint8Array(await arg.arrayBuffer()));
     } else {
-      chunks.push(format("%O", arg));
+      chunks.push(stripVTControlCharacters(format("%O", arg)).replaceAll(`
+`, `
+${" ".repeat(prefix.length)}`));
     }
     if (i < args.length - 1) {
       chunks.push(" ");
@@ -23331,6 +25183,124 @@ function getWorldsList(clientPath) {
   return fs2.readdirSync(savesPath, { withFileTypes: true }).filter((f) => f.isDirectory).map((f) => f.name);
 }
 
+// node_modules/source-map-js/source-map.js
+var $SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+var $SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
+var $SourceNode = require_source_node().SourceNode;
+
+// src/utils/source-map.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+var sourceMapCache = new Map;
+function loadSourceMapSync(jsFilePath) {
+  if (sourceMapCache.has(jsFilePath)) {
+    return sourceMapCache.get(jsFilePath) ?? null;
+  }
+  try {
+    const jsContent = readFileSync(jsFilePath, "utf8");
+    const match = jsContent.match(/\/\/[#@]\s*sourceMappingURL=(.+)$/m);
+    if (!match) {
+      sourceMapCache.set(jsFilePath, null);
+      return null;
+    }
+    const sourceMappingURL = match[1].trim();
+    let mapPath;
+    let mapContent;
+    if (sourceMappingURL.startsWith("data:")) {
+      const base64Match = sourceMappingURL.match(/base64,(.+)/);
+      if (!base64Match) {
+        sourceMapCache.set(jsFilePath, null);
+        return null;
+      }
+      mapContent = Buffer.from(base64Match[1], "base64").toString("utf8");
+    } else {
+      mapPath = resolve(dirname(jsFilePath), sourceMappingURL);
+      mapContent = readFileSync(mapPath, "utf8");
+    }
+    const rawMap = JSON.parse(mapContent);
+    const consumer = new $SourceMapConsumer(rawMap);
+    sourceMapCache.set(jsFilePath, consumer);
+    return consumer;
+  } catch {
+    sourceMapCache.set(jsFilePath, null);
+    return null;
+  }
+}
+function parseStackLine(line) {
+  const patterns = [
+    /^\s*at\s+(?:async\s+)?(.+?)\s+\((.+?):(\d+):(\d+)\)$/,
+    /^\s*at\s+(?:async\s+)?(.+?):(\d+):(\d+)$/,
+    /^\s*at\s+<anonymous>\s+\((.+?):(\d+):(\d+)\)$/
+  ];
+  for (const pattern of patterns) {
+    const match = line.match(pattern);
+    if (match) {
+      if (match.length === 5) {
+        return {
+          original: line,
+          functionName: match[1],
+          filePath: match[2],
+          line: parseInt(match[3], 10),
+          column: parseInt(match[4], 10)
+        };
+      } else if (match.length === 4) {
+        return {
+          original: line,
+          filePath: match[1],
+          line: parseInt(match[2], 10),
+          column: parseInt(match[3], 10)
+        };
+      }
+    }
+  }
+  return { original: line };
+}
+function resolveStackFrame(frame) {
+  if (!frame.filePath || !frame.line || !frame.column) {
+    return frame.original;
+  }
+  if (frame.filePath.includes("(native)") || frame.filePath === "native") {
+    return frame.original;
+  }
+  try {
+    const consumer = loadSourceMapSync(frame.filePath);
+    if (!consumer) {
+      return frame.original;
+    }
+    const pos = consumer.originalPositionFor({
+      line: frame.line,
+      column: frame.column - 1
+    });
+    if (pos.source && pos.line !== null) {
+      const sourceDir = dirname(frame.filePath);
+      const originalPath = resolve(sourceDir, pos.source);
+      const functionPart = pos.name ?? frame.functionName ?? "<anonymous>";
+      const location = `${originalPath}:${pos.line}:${(pos.column ?? 0) + 1}`;
+      if (functionPart) {
+        return `    at ${functionPart} (${location})`;
+      }
+      return `    at ${location}`;
+    }
+  } catch {}
+  return frame.original;
+}
+function resolveStackTrace(stack) {
+  const lines = stack.split(`
+`);
+  const resolvedLines = [];
+  for (const line of lines) {
+    if (line.trimStart().startsWith("at ")) {
+      const frame = parseStackLine(line);
+      const resolved = resolveStackFrame(frame);
+      resolvedLines.push(resolved);
+    } else {
+      resolvedLines.push(line);
+    }
+  }
+  return resolvedLines.join(`
+`);
+}
+
 // src/commands/build/export.ts
 var import_fs_extra2 = __toESM(require_lib(), 1);
 var import_adm_zip = __toESM(require_adm_zip(), 1);
@@ -23393,8 +25363,8 @@ async function createSymlink(folder, packName, newCache, minecraftPath, targetPa
   const comment = `# Sandstone Pack: ${packName}
 `;
   try {
-    const currentlyAllowed = await import_fs_extra2.default.readFile(allowedList, "utf-8");
-    if (!currentlyAllowed.includes(allowPath)) {
+    const currentlyAllowed = (await import_fs_extra2.default.readFile(allowedList, "utf-8")).replace(/\r/g, "");
+    if (currentlyAllowed.match(new RegExp(`^${allowPath}$`, "m")) === null) {
       log("[symlink] Adding workspace to allowed_symlinks.txt. If the game is running please restart it.");
       await import_fs_extra2.default.writeFile(allowedList, `${currentlyAllowed}
 #
@@ -23660,7 +25630,7 @@ async function loadBuildContext(cliOptions, folder) {
       conflictStrategies[resource] = strategy;
     }
   }
-  const sandstoneUrl = pathToFileURL(path5.join(folder, "node_modules", "sandstone", "dist", "index.js"));
+  const sandstoneUrl = pathToFileURL(path5.join(folder, "node_modules", "sandstone", "dist", "exports", "index.js"));
   const { createSandstonePack, resetSandstonePack } = await import(sandstoneUrl);
   const context = {
     workingDir: folder,
@@ -23883,8 +25853,9 @@ async function _buildCommand(opts, _folder, existingContext, watching = false) {
     const traceStart = stackLines.findIndex((line) => line.trimStart().startsWith("at "));
     const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join(`
 `) : "";
-    const formattedError = stackTrace ? `${errorMessage}
-${stackTrace}` : errorMessage;
+    const resolvedStackTrace = stackTrace ? resolveStackTrace(stackTrace) : "";
+    const formattedError = resolvedStackTrace ? `${errorMessage}
+${resolvedStackTrace}` : errorMessage;
     return {
       success: false,
       error: formattedError,
@@ -23918,8 +25889,9 @@ async function buildCommand(opts, _folder, silent2 = false) {
     const traceStart = stackLines.findIndex((line) => line.trimStart().startsWith("at "));
     const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join(`
 `) : "";
-    const formattedError = stackTrace ? `${errorMessage}
-${stackTrace}` : errorMessage;
+    const resolvedStackTrace = stackTrace ? resolveStackTrace(stackTrace) : "";
+    const formattedError = resolvedStackTrace ? `${errorMessage}
+${resolvedStackTrace}` : errorMessage;
     if (!silent2) {
       log(source_default.bgRed.white("BuildError") + source_default.gray(":"), formattedError);
       process.exit(1);
@@ -24496,7 +26468,7 @@ async function createCommand2(_project, opts) {
     default: false
   }) === true ? "library" : "pack";
   const sv = (v) => new import_semver.SemVer(v);
-  const versions = [[sv("1.0.0-beta.3"), sv(CLI_VERSION)]];
+  const versions = [[sv("1.0.0-beta.5"), sv(CLI_VERSION)]];
   const version = await select({
     message: "Which version of Sandstone do you want to use? These are the only supported versions for new projects.",
     choices: versions.map((v) => {
@@ -24876,7 +26848,6 @@ import process12 from "process";
 // node_modules/ink/build/ink.js
 var import_react13 = __toESM(require_react(), 1);
 import process11 from "process";
-
 // node_modules/es-toolkit/dist/function/debounce.mjs
 function debounce(func, debounceMs, { signal, edges } = {}) {
   let pendingThis = undefined;
@@ -25204,7 +27175,7 @@ var getAllProperties = (object) => {
   return properties;
 };
 function autoBind(self, { include, exclude } = {}) {
-  const filter = (key) => {
+  const filter2 = (key) => {
     const match = (pattern) => typeof pattern === "string" ? key === pattern : pattern.test(key);
     if (include) {
       return include.some(match);
@@ -25215,7 +27186,7 @@ function autoBind(self, { include, exclude } = {}) {
     return true;
   };
   for (const [object, key] of getAllProperties(self.constructor.prototype)) {
-    if (key === "constructor" || !filter(key)) {
+    if (key === "constructor" || !filter2(key)) {
       continue;
     }
     const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
@@ -25262,13 +27233,13 @@ var patchConsole = (callback) => {
     callback("stderr", data);
   };
   const internalConsole = new console.Console(stdout, stderr);
-  for (const method of consoleMethods) {
-    originalMethods[method] = console[method];
-    console[method] = internalConsole[method];
+  for (const method2 of consoleMethods) {
+    originalMethods[method2] = console[method2];
+    console[method2] = internalConsole[method2];
   }
   return () => {
-    for (const method of consoleMethods) {
-      console[method] = originalMethods[method];
+    for (const method2 of consoleMethods) {
+      console[method2] = originalMethods[method2];
     }
     originalMethods = {};
   };
@@ -27096,11 +29067,11 @@ function assembleStyles2() {
     },
     hexToRgb: {
       value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
+        const matches2 = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches2) {
           return [0, 0, 0];
         }
-        let [colorString] = matches;
+        let [colorString] = matches2;
         if (colorString.length === 3) {
           colorString = [...colorString].map((character) => character + character).join("");
         }
@@ -27143,11 +29114,11 @@ function assembleStyles2() {
         if (value === 0) {
           return 30;
         }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        let result2 = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
         if (value === 2) {
-          result += 60;
+          result2 += 60;
         }
-        return result;
+        return result2;
       },
       enumerable: false
     },
@@ -27219,18 +29190,18 @@ var wrapWord = (rows, word, columns) => {
   }
 };
 var stringVisibleTrimSpacesRight = (string) => {
-  const words = string.split(" ");
-  let last = words.length;
-  while (last > 0) {
-    if (stringWidth(words[last - 1]) > 0) {
+  const words2 = string.split(" ");
+  let last2 = words2.length;
+  while (last2 > 0) {
+    if (stringWidth(words2[last2 - 1]) > 0) {
       break;
     }
-    last--;
+    last2--;
   }
-  if (last === words.length) {
+  if (last2 === words2.length) {
     return string;
   }
-  return words.slice(0, last).join(" ") + words.slice(last).join("");
+  return words2.slice(0, last2).join(" ") + words2.slice(last2).join("");
 };
 var exec2 = (string, columns, options = {}) => {
   if (options.trim !== false && string.trim() === "") {
@@ -28143,26 +30114,26 @@ $ npm install --save-dev react-devtools-core
     }
   }
 }
-var diff = (before, after) => {
-  if (before === after) {
+var diff = (before2, after2) => {
+  if (before2 === after2) {
     return;
   }
-  if (!before) {
-    return after;
+  if (!before2) {
+    return after2;
   }
   const changed = {};
   let isChanged = false;
-  for (const key of Object.keys(before)) {
-    const isDeleted = after ? !Object.hasOwn(after, key) : true;
+  for (const key of Object.keys(before2)) {
+    const isDeleted = after2 ? !Object.hasOwn(after2, key) : true;
     if (isDeleted) {
       changed[key] = undefined;
       isChanged = true;
     }
   }
-  if (after) {
-    for (const key of Object.keys(after)) {
-      if (after[key] !== before[key]) {
-        changed[key] = after[key];
+  if (after2) {
+    for (const key of Object.keys(after2)) {
+      if (after2[key] !== before2[key]) {
+        changed[key] = after2[key];
         isChanged = true;
       }
     }
@@ -28412,21 +30383,21 @@ var colorize = (str, color, type) => {
     return type === "foreground" ? source_default.hex(color)(str) : source_default.bgHex(color)(str);
   }
   if (color.startsWith("ansi256")) {
-    const matches = ansiRegex2.exec(color);
-    if (!matches) {
+    const matches2 = ansiRegex2.exec(color);
+    if (!matches2) {
       return str;
     }
-    const value = Number(matches[1]);
+    const value = Number(matches2[1]);
     return type === "foreground" ? source_default.ansi256(value)(str) : source_default.bgAnsi256(value)(str);
   }
   if (color.startsWith("rgb")) {
-    const matches = rgbRegex.exec(color);
-    if (!matches) {
+    const matches2 = rgbRegex.exec(color);
+    if (!matches2) {
       return str;
     }
-    const firstValue = Number(matches[1]);
-    const secondValue = Number(matches[2]);
-    const thirdValue = Number(matches[3]);
+    const firstValue = Number(matches2[1]);
+    const secondValue = Number(matches2[2]);
+    const thirdValue = Number(matches2[3]);
     return type === "foreground" ? source_default.rgb(firstValue, secondValue, thirdValue)(str) : source_default.bgRgb(firstValue, secondValue, thirdValue)(str);
   }
   return str;
@@ -29212,13 +31183,13 @@ var createIncremental = (stream, { showCursor = false } = {}) => {
   };
   return render;
 };
-var create = (stream, { showCursor = false, incremental = false } = {}) => {
+var create2 = (stream, { showCursor = false, incremental = false } = {}) => {
   if (incremental) {
     return createIncremental(stream, { showCursor });
   }
   return createStandard(stream, { showCursor });
 };
-var logUpdate = { create };
+var logUpdate = { create: create2 };
 var log_update_default = logUpdate;
 
 // node_modules/ink/build/instances.js
@@ -29304,9 +31275,9 @@ var dist_default2 = convertToSpaces;
 // node_modules/code-excerpt/dist/index.js
 var generateLineNumbers = (line, around) => {
   const lineNumbers = [];
-  const min = line - around;
-  const max = line + around;
-  for (let lineNumber = min;lineNumber <= max; lineNumber++) {
+  const min2 = line - around;
+  const max2 = line + around;
+  for (let lineNumber = min2;lineNumber <= max2; lineNumber++) {
     lineNumbers.push(lineNumber);
   }
   return lineNumbers;
@@ -29370,14 +31341,14 @@ var Box_default = Box;
 
 // node_modules/ink/build/components/Text.js
 var import_react10 = __toESM(require_react(), 1);
-function Text({ color, backgroundColor, dimColor = false, bold = false, italic = false, underline = false, strikethrough = false, inverse = false, wrap = "wrap", children, "aria-label": ariaLabel, "aria-hidden": ariaHidden = false }) {
+function Text({ color, backgroundColor, dimColor = false, bold = false, italic = false, underline = false, strikethrough = false, inverse = false, wrap: wrap2 = "wrap", children, "aria-label": ariaLabel, "aria-hidden": ariaHidden = false }) {
   const { isScreenReaderEnabled } = import_react10.useContext(accessibilityContext);
   const inheritedBackgroundColor = import_react10.useContext(backgroundContext);
   const childrenOrAriaLabel = isScreenReaderEnabled && ariaLabel ? ariaLabel : children;
   if (childrenOrAriaLabel === undefined || childrenOrAriaLabel === null) {
     return null;
   }
-  const transform = (children2) => {
+  const transform2 = (children2) => {
     if (dimColor) {
       children2 = source_default.dim(children2);
     }
@@ -29408,7 +31379,7 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
   if (isScreenReaderEnabled && ariaHidden) {
     return null;
   }
-  return import_react10.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row", textWrap: wrap }, internal_transform: transform }, isScreenReaderEnabled && ariaLabel ? ariaLabel : children);
+  return import_react10.default.createElement("ink-text", { style: { flexGrow: 0, flexShrink: 1, flexDirection: "row", textWrap: wrap2 }, internal_transform: transform2 }, isScreenReaderEnabled && ariaLabel ? ariaLabel : children);
 }
 
 // node_modules/ink/build/components/ErrorOverview.js
@@ -29448,7 +31419,7 @@ function ErrorOverview({ error }) {
 // node_modules/ink/build/components/App.js
 var tab = "\t";
 var shiftTab = "\x1B[Z";
-var escape = "\x1B";
+var escape2 = "\x1B";
 
 class App extends import_react12.PureComponent {
   static displayName = "InternalApp";
@@ -29544,17 +31515,17 @@ Read about how to prevent this error on https://github.com/vadimdemedes/ink/#isr
     }
   };
   handleReadable = () => {
-    let chunk;
-    while ((chunk = this.props.stdin.read()) !== null) {
-      this.handleInput(chunk);
-      this.internal_eventEmitter.emit("input", chunk);
+    let chunk2;
+    while ((chunk2 = this.props.stdin.read()) !== null) {
+      this.handleInput(chunk2);
+      this.internal_eventEmitter.emit("input", chunk2);
     }
   };
   handleInput = (input2) => {
     if (input2 === "\x03" && this.props.exitOnCtrlC) {
       this.handleExit();
     }
-    if (input2 === escape && this.state.activeFocusId) {
+    if (input2 === escape2 && this.state.activeFocusId) {
       this.setState({
         activeFocusId: undefined
       });
@@ -29691,7 +31662,7 @@ Read about how to prevent this error on https://github.com/vadimdemedes/ink/#isr
 }
 
 // node_modules/ink/build/ink.js
-var noop = () => {};
+var noop2 = () => {};
 
 class Ink {
   options;
@@ -29846,7 +31817,7 @@ class Ink {
   };
   render(node) {
     const tree = import_react13.default.createElement(accessibilityContext.Provider, { value: { isScreenReaderEnabled: this.isScreenReaderEnabled } }, import_react13.default.createElement(App, { stdin: this.options.stdin, stdout: this.options.stdout, stderr: this.options.stderr, writeToStdout: this.writeToStdout, writeToStderr: this.writeToStderr, exitOnCtrlC: this.options.exitOnCtrlC, onExit: this.unmount }, node));
-    reconciler_default.updateContainerSync(tree, this.container, null, noop);
+    reconciler_default.updateContainerSync(tree, this.container, null, noop2);
     reconciler_default.flushSyncWork();
   }
   writeToStdout(data) {
@@ -29902,7 +31873,7 @@ class Ink {
       this.log.done();
     }
     this.isUnmounted = true;
-    reconciler_default.updateContainerSync(null, this.container, null, noop);
+    reconciler_default.updateContainerSync(null, this.container, null, noop2);
     reconciler_default.flushSyncWork();
     instances_default.delete(this.options.stdout);
     if (error instanceof Error) {
@@ -29912,9 +31883,9 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve, reject) => {
-      this.resolveExitPromise = resolve;
-      this.rejectExitPromise = reject;
+    this.exitPromise ||= new Promise((resolve2, reject2) => {
+      this.resolveExitPromise = resolve2;
+      this.rejectExitPromise = reject2;
     });
     return this.exitPromise;
   }
@@ -30380,9 +32351,9 @@ function WatchUI({ manual, onManualRebuild, exit }) {
   const [buildResult, setBuildResultState] = import_react27.useState(null);
   const [logLines, setLogLinesState] = import_react27.useState([]);
   const [scrollOffset, setScrollOffset] = import_react27.useState(0);
-  const isError = status === "error" && buildResult?.error;
+  const isError2 = status === "error" && buildResult?.error;
   const isManualPending = manual && status === "pending" && changedFiles.length > 0;
-  const contentMode = isError ? "error" : isManualPending ? "changes" : "logs";
+  const contentMode = isError2 ? "error" : isManualPending ? "changes" : "logs";
   import_react27.useEffect(() => {
     setScrollOffset(0);
   }, [contentMode, buildResult?.error]);
@@ -30393,9 +32364,9 @@ function WatchUI({ manual, onManualRebuild, exit }) {
   const setChangedFiles = import_react27.useCallback((files) => {
     setChangedFilesState(files);
   }, []);
-  const setBuildResult = import_react27.useCallback((result) => {
-    setBuildResultState(result);
-    if (result.success) {
+  const setBuildResult = import_react27.useCallback((result2) => {
+    setBuildResultState(result2);
+    if (result2.success) {
       setStatusState(manual ? "pending" : "watching");
       setChangedFilesState([]);
     } else {
@@ -30412,7 +32383,7 @@ function WatchUI({ manual, onManualRebuild, exit }) {
     });
   }, []);
   const getMaxScroll = import_react27.useCallback(() => {
-    if (isError && buildResult?.error) {
+    if (isError2 && buildResult?.error) {
       return Math.max(0, buildResult.error.split(`
 `).length - CONTENT_LINES);
     } else if (isManualPending) {
@@ -30420,20 +32391,20 @@ function WatchUI({ manual, onManualRebuild, exit }) {
     } else {
       return Math.max(0, logLines.length - CONTENT_LINES);
     }
-  }, [isError, isManualPending, buildResult?.error, logLines.length]);
+  }, [isError2, isManualPending, buildResult?.error, logLines.length]);
   use_input_default((input2, key) => {
     if (input2 === "q" || key.ctrl && input2 === "c") {
       exit();
     }
     const maxScroll = getMaxScroll();
     if (key.upArrow) {
-      if (isError) {
+      if (isError2) {
         setScrollOffset((prev) => Math.max(0, prev - 1));
       } else {
         setScrollOffset((prev) => Math.min(maxScroll, prev + 1));
       }
     } else if (key.downArrow) {
-      if (isError) {
+      if (isError2) {
         setScrollOffset((prev) => Math.min(maxScroll, prev + 1));
       } else {
         setScrollOffset((prev) => Math.max(0, prev - 1));
@@ -30470,7 +32441,7 @@ function WatchUI({ manual, onManualRebuild, exit }) {
   const footerParts = [];
   if (manual)
     footerParts.push("R/Enter: rebuild");
-  if (logLines.length > CONTENT_LINES || isError && buildResult?.error && buildResult.error.split(`
+  if (logLines.length > CONTENT_LINES || isError2 && buildResult?.error && buildResult.error.split(`
 `).length > CONTENT_LINES) {
     footerParts.push("\u2191\u2193: scroll");
   }
@@ -30555,7 +32526,7 @@ function WatchUI({ manual, onManualRebuild, exit }) {
         color: "gray",
         children: "No build results yet"
       }, undefined, false, undefined, this),
-      isError ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
+      isError2 ? /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
         color: "yellow",
         children: "Waiting for changes to retry..."
       }, undefined, false, undefined, this) : /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Text, {
@@ -30572,16 +32543,16 @@ function getWatchUIAPI() {
   return globalThis.__watchUIAPI;
 }
 
-// ../hot-hook/packages/hot_hook/build/src/hot.js
+// node_modules/@sandstone-mc/hot-hook/build/src/hot.js
 import { register } from "module";
 import { MessageChannel as MessageChannel2 } from "worker_threads";
 
-// ../hot-hook/packages/hot_hook/build/src/debug.js
+// node_modules/@sandstone-mc/hot-hook/build/src/debug.js
 import { debuglog } from "util";
 var debug = debuglog("hot-hook");
 var debug_default = debug;
 
-// ../hot-hook/packages/hot_hook/build/src/hot.js
+// node_modules/@sandstone-mc/hot-hook/build/src/hot.js
 class Hot {
   #options;
   #messageChannel;
@@ -30664,8 +32635,8 @@ class Hot {
   }
   async dump() {
     this.#messageChannel.port1.postMessage({ type: "hot-hook:dump" });
-    const result = await new Promise((resolve) => this.#messageChannel.port1.once("message", (message) => resolve(message)));
-    return result.dump;
+    const result2 = await new Promise((resolve2) => this.#messageChannel.port1.once("message", (message) => resolve2(message)));
+    return result2.dump;
   }
   notifyFileChange(filePath) {
     this.#messageChannel.port1.postMessage({ type: "hot-hook:file-changed", path: filePath });
@@ -30676,7 +32647,7 @@ globalThis.hot = hot;
 
 // src/commands/watch.ts
 var import_fs_extra7 = __toESM(require_lib(), 1);
-import { join, relative } from "path";
+import { join as join2, relative } from "path";
 var originalConsole = globalThis.console;
 var consoleWrapped = false;
 function enableConsoleCapture() {
@@ -30692,8 +32663,14 @@ function enableConsoleCapture() {
     const traceObj = { stack: "" };
     Error.captureStackTrace(traceObj, globalThis.console.trace);
     const cleanedStack = traceObj.stack.replace(/^Error\n/, "").replace(/\?hot-hook=\d+/g, "").replace(/file:\/\/\/?/g, "");
+    const stackLines = cleanedStack.split(`
+`);
+    const traceStart = stackLines.findIndex((line) => line.trimStart().startsWith("at "));
+    const stackTrace = traceStart >= 0 ? stackLines.slice(traceStart).join(`
+`) : "";
+    const resolvedStack = stackTrace ? resolveStackTrace(stackTrace) : cleanedStack;
     logTrace(...args, `
-` + cleanedStack);
+` + resolvedStack);
   };
 }
 function disableConsoleCapture() {
@@ -30701,8 +32678,8 @@ function disableConsoleCapture() {
     return;
   consoleWrapped = false;
   const methodsToRestore = ["log", "info", "warn", "error", "debug", "trace"];
-  for (const method of methodsToRestore) {
-    globalThis.console[method] = originalConsole[method].bind(originalConsole);
+  for (const method2 of methodsToRestore) {
+    globalThis.console[method2] = originalConsole[method2].bind(originalConsole);
   }
 }
 async function watchCommand(opts) {
@@ -30712,7 +32689,7 @@ async function watchCommand(opts) {
   let buildContext;
   let hotInitialized = false;
   let lastBuildFailed = false;
-  const folder = opts.library ? join(opts.path, "test") : opts.path;
+  const folder = opts.library ? join2(opts.path, "test") : opts.path;
   let subscription;
   initLogger(folder);
   setLiveLogCallback((level, args) => {
@@ -30759,7 +32736,7 @@ async function watchCommand(opts) {
     }
     if (!hotInitialized) {
       await hot.init({
-        root: join(folder, JSON.parse(await import_fs_extra7.default.readFile(join(folder, "package.json"), "utf-8"))["module"]),
+        root: join2(folder, JSON.parse(await import_fs_extra7.default.readFile(join2(folder, "package.json"), "utf-8"))["module"]),
         globalSingletons: ["**/node_modules/sandstone/**", "**/sandstone/dist/**"],
         watch: false
       });
@@ -30792,35 +32769,35 @@ async function watchCommand(opts) {
         hot.notifyFileChange(change.path);
       }
       if (libChanges.length !== 0) {
-        const libModuleFiles = await import_fs_extra7.default.readdir(join(opts.path, "lib"), { recursive: true });
+        const libModuleFiles = await import_fs_extra7.default.readdir(join2(opts.path, "lib"), { recursive: true });
         for (const file of libModuleFiles) {
-          hot.notifyFileChange(join(opts.path, "lib", file));
+          hot.notifyFileChange(join2(opts.path, "lib", file));
         }
       }
       if (changes.length > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 10));
+        await new Promise((resolve2) => setTimeout(resolve2, 10));
       }
     }
     enableConsoleCapture();
-    let result;
+    let result2;
     try {
-      result = await _buildCommand(opts, folder, buildContext, true);
+      result2 = await _buildCommand(opts, folder, buildContext, true);
     } finally {
       disableConsoleCapture();
     }
-    if (result.success && result.sandstoneConfig !== undefined) {
+    if (result2.success && result2.sandstoneConfig !== undefined) {
       buildContext = {
-        sandstoneConfig: result.sandstoneConfig,
-        sandstonePack: result.sandstonePack,
-        resetSandstonePack: result.resetSandstonePack
+        sandstoneConfig: result2.sandstoneConfig,
+        sandstonePack: result2.sandstonePack,
+        resetSandstonePack: result2.resetSandstonePack
       };
     }
-    api?.setBuildResult(result);
-    if (result.success) {
-      log(`Build successful: ${result.resourceCounts.functions} functions, ${result.resourceCounts.other} others`);
+    api?.setBuildResult(result2);
+    if (result2.success) {
+      log(`Build successful: ${result2.resourceCounts.functions} functions, ${result2.resourceCounts.other} others`);
       lastBuildFailed = false;
     } else {
-      logError(result.error);
+      logError(result2.error);
       lastBuildFailed = true;
     }
     alreadyBuilding = false;
@@ -30994,3 +32971,5 @@ install.command("vanilla").alias("smithed").description("Install Vanilla Smithed
 CLI.command("uninstall").alias("remove").description("Uninstall Vanilla Smithed libraries. \u26CF").action(uninstallVanillaCommand).addArgument(new Argument("[libraries...]", "Optional. Libraries to uninstall. When unlisted, a selector will appear."));
 CLI.command("refresh").description("Clear & update cached Smithed libraries. \u26CF").action(refreshCommand);
 CLI.parse(process.argv);
+
+//# debugId=CA02D3AA5926561C64756E2164756E21