@tanstack/query-devtools 5.4.2 → 5.8.2

package/build/chunk/{JRAMSUCV.jsx → MJH6GUJH.jsx}

@@ -277,12 +277,12 @@ function untrack(fn) {
   }
 }
 function on(deps, fn, options) {
-  const isArray = Array.isArray(deps);
+  const isArray3 = Array.isArray(deps);
   let prevInput;
   let defer = options && options.defer;
   return (prevValue) => {
     let input;
-    if (isArray) {
+    if (isArray3) {
       input = Array(deps.length);
       for (let i = 0; i < deps.length; i++)
         input[i] = deps[i]();
@@ -2032,6 +2032,1211 @@ function Dynamic(props) {
   });
 }
 
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/double-indexed-kv.js
+var DoubleIndexedKV = (
+  /** @class */
+  function() {
+    function DoubleIndexedKV2() {
+      this.keyToValue = /* @__PURE__ */ new Map();
+      this.valueToKey = /* @__PURE__ */ new Map();
+    }
+    DoubleIndexedKV2.prototype.set = function(key, value) {
+      this.keyToValue.set(key, value);
+      this.valueToKey.set(value, key);
+    };
+    DoubleIndexedKV2.prototype.getByKey = function(key) {
+      return this.keyToValue.get(key);
+    };
+    DoubleIndexedKV2.prototype.getByValue = function(value) {
+      return this.valueToKey.get(value);
+    };
+    DoubleIndexedKV2.prototype.clear = function() {
+      this.keyToValue.clear();
+      this.valueToKey.clear();
+    };
+    return DoubleIndexedKV2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/registry.js
+var Registry = (
+  /** @class */
+  function() {
+    function Registry2(generateIdentifier) {
+      this.generateIdentifier = generateIdentifier;
+      this.kv = new DoubleIndexedKV();
+    }
+    Registry2.prototype.register = function(value, identifier) {
+      if (this.kv.getByValue(value)) {
+        return;
+      }
+      if (!identifier) {
+        identifier = this.generateIdentifier(value);
+      }
+      this.kv.set(identifier, value);
+    };
+    Registry2.prototype.clear = function() {
+      this.kv.clear();
+    };
+    Registry2.prototype.getIdentifier = function(value) {
+      return this.kv.getByValue(value);
+    };
+    Registry2.prototype.getValue = function(identifier) {
+      return this.kv.getByKey(identifier);
+    };
+    return Registry2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/class-registry.js
+var __extends = function() {
+  var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+      d2.__proto__ = b2;
+    } || function(d2, b2) {
+      for (var p in b2)
+        if (Object.prototype.hasOwnProperty.call(b2, p))
+          d2[p] = b2[p];
+    };
+    return extendStatics(d, b);
+  };
+  return function(d, b) {
+    if (typeof b !== "function" && b !== null)
+      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() {
+      this.constructor = d;
+    }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+var ClassRegistry = (
+  /** @class */
+  function(_super) {
+    __extends(ClassRegistry2, _super);
+    function ClassRegistry2() {
+      var _this = _super.call(this, function(c) {
+        return c.name;
+      }) || this;
+      _this.classToAllowedProps = /* @__PURE__ */ new Map();
+      return _this;
+    }
+    ClassRegistry2.prototype.register = function(value, options) {
+      if (typeof options === "object") {
+        if (options.allowProps) {
+          this.classToAllowedProps.set(value, options.allowProps);
+        }
+        _super.prototype.register.call(this, value, options.identifier);
+      } else {
+        _super.prototype.register.call(this, value, options);
+      }
+    };
+    ClassRegistry2.prototype.getAllowedProps = function(value) {
+      return this.classToAllowedProps.get(value);
+    };
+    return ClassRegistry2;
+  }(Registry)
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/util.js
+var __read = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+function valuesOfObj(record) {
+  if ("values" in Object) {
+    return Object.values(record);
+  }
+  var values = [];
+  for (var key in record) {
+    if (record.hasOwnProperty(key)) {
+      values.push(record[key]);
+    }
+  }
+  return values;
+}
+function find(record, predicate) {
+  var values = valuesOfObj(record);
+  if ("find" in values) {
+    return values.find(predicate);
+  }
+  var valuesNotNever = values;
+  for (var i = 0; i < valuesNotNever.length; i++) {
+    var value = valuesNotNever[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+function forEach(record, run) {
+  Object.entries(record).forEach(function(_a) {
+    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    return run(value, key);
+  });
+}
+function includes(arr, value) {
+  return arr.indexOf(value) !== -1;
+}
+function findArr(record, predicate) {
+  for (var i = 0; i < record.length; i++) {
+    var value = record[i];
+    if (predicate(value)) {
+      return value;
+    }
+  }
+  return void 0;
+}
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/custom-transformer-registry.js
+var CustomTransformerRegistry = (
+  /** @class */
+  function() {
+    function CustomTransformerRegistry2() {
+      this.transfomers = {};
+    }
+    CustomTransformerRegistry2.prototype.register = function(transformer) {
+      this.transfomers[transformer.name] = transformer;
+    };
+    CustomTransformerRegistry2.prototype.findApplicable = function(v) {
+      return find(this.transfomers, function(transformer) {
+        return transformer.isApplicable(v);
+      });
+    };
+    CustomTransformerRegistry2.prototype.findByName = function(name) {
+      return this.transfomers[name];
+    };
+    return CustomTransformerRegistry2;
+  }()
+);
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/is.js
+var getType = function(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+};
+var isUndefined = function(payload) {
+  return typeof payload === "undefined";
+};
+var isNull = function(payload) {
+  return payload === null;
+};
+var isPlainObject = function(payload) {
+  if (typeof payload !== "object" || payload === null)
+    return false;
+  if (payload === Object.prototype)
+    return false;
+  if (Object.getPrototypeOf(payload) === null)
+    return true;
+  return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = function(payload) {
+  return isPlainObject(payload) && Object.keys(payload).length === 0;
+};
+var isArray = function(payload) {
+  return Array.isArray(payload);
+};
+var isString = function(payload) {
+  return typeof payload === "string";
+};
+var isNumber = function(payload) {
+  return typeof payload === "number" && !isNaN(payload);
+};
+var isBoolean = function(payload) {
+  return typeof payload === "boolean";
+};
+var isRegExp = function(payload) {
+  return payload instanceof RegExp;
+};
+var isMap = function(payload) {
+  return payload instanceof Map;
+};
+var isSet = function(payload) {
+  return payload instanceof Set;
+};
+var isSymbol = function(payload) {
+  return getType(payload) === "Symbol";
+};
+var isDate = function(payload) {
+  return payload instanceof Date && !isNaN(payload.valueOf());
+};
+var isError = function(payload) {
+  return payload instanceof Error;
+};
+var isNaNValue = function(payload) {
+  return typeof payload === "number" && isNaN(payload);
+};
+var isPrimitive = function(payload) {
+  return isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+};
+var isBigint = function(payload) {
+  return typeof payload === "bigint";
+};
+var isInfinite = function(payload) {
+  return payload === Infinity || payload === -Infinity;
+};
+var isTypedArray = function(payload) {
+  return ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+};
+var isURL = function(payload) {
+  return payload instanceof URL;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/pathstringifier.js
+var escapeKey = function(key) {
+  return key.replace(/\./g, "\\.");
+};
+var stringifyPath = function(path) {
+  return path.map(String).map(escapeKey).join(".");
+};
+var parsePath = function(string) {
+  var result = [];
+  var segment = "";
+  for (var i = 0; i < string.length; i++) {
+    var char = string.charAt(i);
+    var isEscapedDot = char === "\\" && string.charAt(i + 1) === ".";
+    if (isEscapedDot) {
+      segment += ".";
+      i++;
+      continue;
+    }
+    var isEndOfSegment = char === ".";
+    if (isEndOfSegment) {
+      result.push(segment);
+      segment = "";
+      continue;
+    }
+    segment += char;
+  }
+  var lastSegment = segment;
+  result.push(lastSegment);
+  return result;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/transformer.js
+var __assign = function() {
+  __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+var __read2 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+function simpleTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var simpleRules = [
+  simpleTransformation(isUndefined, "undefined", function() {
+    return null;
+  }, function() {
+    return void 0;
+  }),
+  simpleTransformation(isBigint, "bigint", function(v) {
+    return v.toString();
+  }, function(v) {
+    if (typeof BigInt !== "undefined") {
+      return BigInt(v);
+    }
+    return v;
+  }),
+  simpleTransformation(isDate, "Date", function(v) {
+    return v.toISOString();
+  }, function(v) {
+    return new Date(v);
+  }),
+  simpleTransformation(isError, "Error", function(v, superJson) {
+    var baseError = {
+      name: v.name,
+      message: v.message
+    };
+    superJson.allowedErrorProps.forEach(function(prop) {
+      baseError[prop] = v[prop];
+    });
+    return baseError;
+  }, function(v, superJson) {
+    var e = new Error(v.message);
+    e.name = v.name;
+    e.stack = v.stack;
+    superJson.allowedErrorProps.forEach(function(prop) {
+      e[prop] = v[prop];
+    });
+    return e;
+  }),
+  simpleTransformation(isRegExp, "regexp", function(v) {
+    return "" + v;
+  }, function(regex) {
+    var body = regex.slice(1, regex.lastIndexOf("/"));
+    var flags = regex.slice(regex.lastIndexOf("/") + 1);
+    return new RegExp(body, flags);
+  }),
+  simpleTransformation(
+    isSet,
+    "set",
+    // (sets only exist in es6+)
+    // eslint-disable-next-line es5/no-es6-methods
+    function(v) {
+      return __spreadArray([], __read2(v.values()));
+    },
+    function(v) {
+      return new Set(v);
+    }
+  ),
+  simpleTransformation(isMap, "map", function(v) {
+    return __spreadArray([], __read2(v.entries()));
+  }, function(v) {
+    return new Map(v);
+  }),
+  simpleTransformation(function(v) {
+    return isNaNValue(v) || isInfinite(v);
+  }, "number", function(v) {
+    if (isNaNValue(v)) {
+      return "NaN";
+    }
+    if (v > 0) {
+      return "Infinity";
+    } else {
+      return "-Infinity";
+    }
+  }, Number),
+  simpleTransformation(function(v) {
+    return v === 0 && 1 / v === -Infinity;
+  }, "number", function() {
+    return "-0";
+  }, Number),
+  simpleTransformation(isURL, "URL", function(v) {
+    return v.toString();
+  }, function(v) {
+    return new URL(v);
+  })
+];
+function compositeTransformation(isApplicable, annotation, transform, untransform) {
+  return {
+    isApplicable,
+    annotation,
+    transform,
+    untransform
+  };
+}
+var symbolRule = compositeTransformation(function(s, superJson) {
+  if (isSymbol(s)) {
+    var isRegistered = !!superJson.symbolRegistry.getIdentifier(s);
+    return isRegistered;
+  }
+  return false;
+}, function(s, superJson) {
+  var identifier = superJson.symbolRegistry.getIdentifier(s);
+  return ["symbol", identifier];
+}, function(v) {
+  return v.description;
+}, function(_, a, superJson) {
+  var value = superJson.symbolRegistry.getValue(a[1]);
+  if (!value) {
+    throw new Error("Trying to deserialize unknown symbol");
+  }
+  return value;
+});
+var constructorToName = [
+  Int8Array,
+  Uint8Array,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  Uint8ClampedArray
+].reduce(function(obj, ctor) {
+  obj[ctor.name] = ctor;
+  return obj;
+}, {});
+var typedArrayRule = compositeTransformation(isTypedArray, function(v) {
+  return ["typed-array", v.constructor.name];
+}, function(v) {
+  return __spreadArray([], __read2(v));
+}, function(v, a) {
+  var ctor = constructorToName[a[1]];
+  if (!ctor) {
+    throw new Error("Trying to deserialize unknown typed array");
+  }
+  return new ctor(v);
+});
+function isInstanceOfRegisteredClass(potentialClass, superJson) {
+  if (potentialClass === null || potentialClass === void 0 ? void 0 : potentialClass.constructor) {
+    var isRegistered = !!superJson.classRegistry.getIdentifier(potentialClass.constructor);
+    return isRegistered;
+  }
+  return false;
+}
+var classRule = compositeTransformation(isInstanceOfRegisteredClass, function(clazz, superJson) {
+  var identifier = superJson.classRegistry.getIdentifier(clazz.constructor);
+  return ["class", identifier];
+}, function(clazz, superJson) {
+  var allowedProps = superJson.classRegistry.getAllowedProps(clazz.constructor);
+  if (!allowedProps) {
+    return __assign({}, clazz);
+  }
+  var result = {};
+  allowedProps.forEach(function(prop) {
+    result[prop] = clazz[prop];
+  });
+  return result;
+}, function(v, a, superJson) {
+  var clazz = superJson.classRegistry.getValue(a[1]);
+  if (!clazz) {
+    throw new Error("Trying to deserialize unknown class - check https://github.com/blitz-js/superjson/issues/116#issuecomment-773996564");
+  }
+  return Object.assign(Object.create(clazz.prototype), v);
+});
+var customRule = compositeTransformation(function(value, superJson) {
+  return !!superJson.customTransformerRegistry.findApplicable(value);
+}, function(value, superJson) {
+  var transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return ["custom", transformer.name];
+}, function(value, superJson) {
+  var transformer = superJson.customTransformerRegistry.findApplicable(value);
+  return transformer.serialize(value);
+}, function(v, a, superJson) {
+  var transformer = superJson.customTransformerRegistry.findByName(a[1]);
+  if (!transformer) {
+    throw new Error("Trying to deserialize unknown custom value");
+  }
+  return transformer.deserialize(v);
+});
+var compositeRules = [classRule, symbolRule, customRule, typedArrayRule];
+var transformValue = function(value, superJson) {
+  var applicableCompositeRule = findArr(compositeRules, function(rule) {
+    return rule.isApplicable(value, superJson);
+  });
+  if (applicableCompositeRule) {
+    return {
+      value: applicableCompositeRule.transform(value, superJson),
+      type: applicableCompositeRule.annotation(value, superJson)
+    };
+  }
+  var applicableSimpleRule = findArr(simpleRules, function(rule) {
+    return rule.isApplicable(value, superJson);
+  });
+  if (applicableSimpleRule) {
+    return {
+      value: applicableSimpleRule.transform(value, superJson),
+      type: applicableSimpleRule.annotation
+    };
+  }
+  return void 0;
+};
+var simpleRulesByAnnotation = {};
+simpleRules.forEach(function(rule) {
+  simpleRulesByAnnotation[rule.annotation] = rule;
+});
+var untransformValue = function(json, type, superJson) {
+  if (isArray(type)) {
+    switch (type[0]) {
+      case "symbol":
+        return symbolRule.untransform(json, type, superJson);
+      case "class":
+        return classRule.untransform(json, type, superJson);
+      case "custom":
+        return customRule.untransform(json, type, superJson);
+      case "typed-array":
+        return typedArrayRule.untransform(json, type, superJson);
+      default:
+        throw new Error("Unknown transformation: " + type);
+    }
+  } else {
+    var transformation = simpleRulesByAnnotation[type];
+    if (!transformation) {
+      throw new Error("Unknown transformation: " + type);
+    }
+    return transformation.untransform(json, superJson);
+  }
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/accessDeep.js
+var getNthKey = function(value, n) {
+  var keys = value.keys();
+  while (n > 0) {
+    keys.next();
+    n--;
+  }
+  return keys.next().value;
+};
+function validatePath(path) {
+  if (includes(path, "__proto__")) {
+    throw new Error("__proto__ is not allowed as a property");
+  }
+  if (includes(path, "prototype")) {
+    throw new Error("prototype is not allowed as a property");
+  }
+  if (includes(path, "constructor")) {
+    throw new Error("constructor is not allowed as a property");
+  }
+}
+var getDeep = function(object, path) {
+  validatePath(path);
+  for (var i = 0; i < path.length; i++) {
+    var key = path[i];
+    if (isSet(object)) {
+      object = getNthKey(object, +key);
+    } else if (isMap(object)) {
+      var row = +key;
+      var type = +path[++i] === 0 ? "key" : "value";
+      var keyOfRow = getNthKey(object, row);
+      switch (type) {
+        case "key":
+          object = keyOfRow;
+          break;
+        case "value":
+          object = object.get(keyOfRow);
+          break;
+      }
+    } else {
+      object = object[key];
+    }
+  }
+  return object;
+};
+var setDeep = function(object, path, mapper) {
+  validatePath(path);
+  if (path.length === 0) {
+    return mapper(object);
+  }
+  var parent = object;
+  for (var i = 0; i < path.length - 1; i++) {
+    var key = path[i];
+    if (isArray(parent)) {
+      var index = +key;
+      parent = parent[index];
+    } else if (isPlainObject(parent)) {
+      parent = parent[key];
+    } else if (isSet(parent)) {
+      var row = +key;
+      parent = getNthKey(parent, row);
+    } else if (isMap(parent)) {
+      var isEnd = i === path.length - 2;
+      if (isEnd) {
+        break;
+      }
+      var row = +key;
+      var type = +path[++i] === 0 ? "key" : "value";
+      var keyOfRow = getNthKey(parent, row);
+      switch (type) {
+        case "key":
+          parent = keyOfRow;
+          break;
+        case "value":
+          parent = parent.get(keyOfRow);
+          break;
+      }
+    }
+  }
+  var lastKey = path[path.length - 1];
+  if (isArray(parent)) {
+    parent[+lastKey] = mapper(parent[+lastKey]);
+  } else if (isPlainObject(parent)) {
+    parent[lastKey] = mapper(parent[lastKey]);
+  }
+  if (isSet(parent)) {
+    var oldValue = getNthKey(parent, +lastKey);
+    var newValue = mapper(oldValue);
+    if (oldValue !== newValue) {
+      parent["delete"](oldValue);
+      parent.add(newValue);
+    }
+  }
+  if (isMap(parent)) {
+    var row = +path[path.length - 2];
+    var keyToRow = getNthKey(parent, row);
+    var type = +lastKey === 0 ? "key" : "value";
+    switch (type) {
+      case "key": {
+        var newKey = mapper(keyToRow);
+        parent.set(newKey, parent.get(keyToRow));
+        if (newKey !== keyToRow) {
+          parent["delete"](keyToRow);
+        }
+        break;
+      }
+      case "value": {
+        parent.set(keyToRow, mapper(parent.get(keyToRow)));
+        break;
+      }
+    }
+  }
+  return object;
+};
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/plainer.js
+var __read3 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray2 = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+function traverse(tree, walker2, origin) {
+  if (origin === void 0) {
+    origin = [];
+  }
+  if (!tree) {
+    return;
+  }
+  if (!isArray(tree)) {
+    forEach(tree, function(subtree, key) {
+      return traverse(subtree, walker2, __spreadArray2(__spreadArray2([], __read3(origin)), __read3(parsePath(key))));
+    });
+    return;
+  }
+  var _a = __read3(tree, 2), nodeValue = _a[0], children2 = _a[1];
+  if (children2) {
+    forEach(children2, function(child, key) {
+      traverse(child, walker2, __spreadArray2(__spreadArray2([], __read3(origin)), __read3(parsePath(key))));
+    });
+  }
+  walker2(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, superJson) {
+  traverse(annotations, function(type, path) {
+    plain = setDeep(plain, path, function(v) {
+      return untransformValue(v, type, superJson);
+    });
+  });
+  return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations) {
+  function apply(identicalPaths, path) {
+    var object = getDeep(plain, parsePath(path));
+    identicalPaths.map(parsePath).forEach(function(identicalObjectPath) {
+      plain = setDeep(plain, identicalObjectPath, function() {
+        return object;
+      });
+    });
+  }
+  if (isArray(annotations)) {
+    var _a = __read3(annotations, 2), root = _a[0], other = _a[1];
+    root.forEach(function(identicalPath) {
+      plain = setDeep(plain, parsePath(identicalPath), function() {
+        return plain;
+      });
+    });
+    if (other) {
+      forEach(other, apply);
+    }
+  } else {
+    forEach(annotations, apply);
+  }
+  return plain;
+}
+var isDeep = function(object, superJson) {
+  return isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isInstanceOfRegisteredClass(object, superJson);
+};
+function addIdentity(object, path, identities) {
+  var existingSet = identities.get(object);
+  if (existingSet) {
+    existingSet.push(path);
+  } else {
+    identities.set(object, [path]);
+  }
+}
+function generateReferentialEqualityAnnotations(identitites) {
+  var result = {};
+  var rootEqualityPaths = void 0;
+  identitites.forEach(function(paths) {
+    if (paths.length <= 1) {
+      return;
+    }
+    var _a = __read3(paths.map(function(path) {
+      return path.map(String);
+    }).sort(function(a, b) {
+      return a.length - b.length;
+    })), shortestPath = _a[0], identicalPaths = _a.slice(1);
+    if (shortestPath.length === 0) {
+      rootEqualityPaths = identicalPaths.map(stringifyPath);
+    } else {
+      result[stringifyPath(shortestPath)] = identicalPaths.map(stringifyPath);
+    }
+  });
+  if (rootEqualityPaths) {
+    if (isEmptyObject(result)) {
+      return [rootEqualityPaths];
+    } else {
+      return [rootEqualityPaths, result];
+    }
+  } else {
+    return isEmptyObject(result) ? void 0 : result;
+  }
+}
+var walker = function(object, identities, superJson, path, objectsInThisPath) {
+  var _a;
+  if (path === void 0) {
+    path = [];
+  }
+  if (objectsInThisPath === void 0) {
+    objectsInThisPath = [];
+  }
+  if (!isPrimitive(object)) {
+    addIdentity(object, path, identities);
+  }
+  if (!isDeep(object, superJson)) {
+    var transformed_1 = transformValue(object, superJson);
+    if (transformed_1) {
+      return {
+        transformedValue: transformed_1.value,
+        annotations: [transformed_1.type]
+      };
+    } else {
+      return {
+        transformedValue: object
+      };
+    }
+  }
+  if (includes(objectsInThisPath, object)) {
+    return {
+      transformedValue: null
+    };
+  }
+  var transformationResult = transformValue(object, superJson);
+  var transformed = (_a = transformationResult === null || transformationResult === void 0 ? void 0 : transformationResult.value) !== null && _a !== void 0 ? _a : object;
+  if (!isPrimitive(object)) {
+    objectsInThisPath = __spreadArray2(__spreadArray2([], __read3(objectsInThisPath)), [object]);
+  }
+  var transformedValue = isArray(transformed) ? [] : {};
+  var innerAnnotations = {};
+  forEach(transformed, function(value, index) {
+    var recursiveResult = walker(value, identities, superJson, __spreadArray2(__spreadArray2([], __read3(path)), [index]), objectsInThisPath);
+    transformedValue[index] = recursiveResult.transformedValue;
+    if (isArray(recursiveResult.annotations)) {
+      innerAnnotations[index] = recursiveResult.annotations;
+    } else if (isPlainObject(recursiveResult.annotations)) {
+      forEach(recursiveResult.annotations, function(tree, key) {
+        innerAnnotations[escapeKey(index) + "." + key] = tree;
+      });
+    }
+  });
+  if (isEmptyObject(innerAnnotations)) {
+    return {
+      transformedValue,
+      annotations: !!transformationResult ? [transformationResult.type] : void 0
+    };
+  } else {
+    return {
+      transformedValue,
+      annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+    };
+  }
+};
+
+// ../../node_modules/.pnpm/is-what@4.1.15/node_modules/is-what/dist/index.js
+function getType2(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+function isUndefined2(payload) {
+  return getType2(payload) === "Undefined";
+}
+function isNull2(payload) {
+  return getType2(payload) === "Null";
+}
+function isPlainObject2(payload) {
+  if (getType2(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+function isArray2(payload) {
+  return getType2(payload) === "Array";
+}
+var isNullOrUndefined = isOneOf(isNull2, isUndefined2);
+function isOneOf(a, b, c, d, e) {
+  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
+}
+
+// ../../node_modules/.pnpm/copy-anything@3.0.5/node_modules/copy-anything/dist/index.js
+function assignProp2(carry, key, newVal, originalObject, includeNonenumerable) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (includeNonenumerable && propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function copy(target, options = {}) {
+  if (isArray2(target)) {
+    return target.map((item) => copy(item, options));
+  }
+  if (!isPlainObject2(target)) {
+    return target;
+  }
+  const props = Object.getOwnPropertyNames(target);
+  const symbols = Object.getOwnPropertySymbols(target);
+  return [...props, ...symbols].reduce((carry, key) => {
+    if (isArray2(options.props) && !options.props.includes(key)) {
+      return carry;
+    }
+    const val = target[key];
+    const newVal = copy(val, options);
+    assignProp2(carry, key, newVal, target, options.nonenumerable);
+    return carry;
+  }, {});
+}
+
+// ../../node_modules/.pnpm/superjson@1.12.4/node_modules/superjson/dist/esm/index.js
+var __assign2 = function() {
+  __assign2 = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign2.apply(this, arguments);
+};
+var __read4 = function(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m)
+    return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+      ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"]))
+        m.call(i);
+    } finally {
+      if (e)
+        throw e.error;
+    }
+  }
+  return ar;
+};
+var __spreadArray3 = function(to, from) {
+  for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+    to[j] = from[i];
+  return to;
+};
+var SuperJSON = (
+  /** @class */
+  function() {
+    function SuperJSON2() {
+      this.classRegistry = new ClassRegistry();
+      this.symbolRegistry = new Registry(function(s) {
+        var _a;
+        return (_a = s.description) !== null && _a !== void 0 ? _a : "";
+      });
+      this.customTransformerRegistry = new CustomTransformerRegistry();
+      this.allowedErrorProps = [];
+    }
+    SuperJSON2.prototype.serialize = function(object) {
+      var identities = /* @__PURE__ */ new Map();
+      var output = walker(object, identities, this);
+      var res = {
+        json: output.transformedValue
+      };
+      if (output.annotations) {
+        res.meta = __assign2(__assign2({}, res.meta), { values: output.annotations });
+      }
+      var equalityAnnotations = generateReferentialEqualityAnnotations(identities);
+      if (equalityAnnotations) {
+        res.meta = __assign2(__assign2({}, res.meta), { referentialEqualities: equalityAnnotations });
+      }
+      return res;
+    };
+    SuperJSON2.prototype.deserialize = function(payload) {
+      var json = payload.json, meta = payload.meta;
+      var result = copy(json);
+      if (meta === null || meta === void 0 ? void 0 : meta.values) {
+        result = applyValueAnnotations(result, meta.values, this);
+      }
+      if (meta === null || meta === void 0 ? void 0 : meta.referentialEqualities) {
+        result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities);
+      }
+      return result;
+    };
+    SuperJSON2.prototype.stringify = function(object) {
+      return JSON.stringify(this.serialize(object));
+    };
+    SuperJSON2.prototype.parse = function(string) {
+      return this.deserialize(JSON.parse(string));
+    };
+    SuperJSON2.prototype.registerClass = function(v, options) {
+      this.classRegistry.register(v, options);
+    };
+    SuperJSON2.prototype.registerSymbol = function(v, identifier) {
+      this.symbolRegistry.register(v, identifier);
+    };
+    SuperJSON2.prototype.registerCustom = function(transformer, name) {
+      this.customTransformerRegistry.register(__assign2({ name }, transformer));
+    };
+    SuperJSON2.prototype.allowErrorProps = function() {
+      var _a;
+      var props = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        props[_i] = arguments[_i];
+      }
+      (_a = this.allowedErrorProps).push.apply(_a, __spreadArray3([], __read4(props)));
+    };
+    SuperJSON2.defaultInstance = new SuperJSON2();
+    SuperJSON2.serialize = SuperJSON2.defaultInstance.serialize.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.deserialize = SuperJSON2.defaultInstance.deserialize.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.stringify = SuperJSON2.defaultInstance.stringify.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.parse = SuperJSON2.defaultInstance.parse.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerClass = SuperJSON2.defaultInstance.registerClass.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerSymbol = SuperJSON2.defaultInstance.registerSymbol.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.registerCustom = SuperJSON2.defaultInstance.registerCustom.bind(SuperJSON2.defaultInstance);
+    SuperJSON2.allowErrorProps = SuperJSON2.defaultInstance.allowErrorProps.bind(SuperJSON2.defaultInstance);
+    return SuperJSON2;
+  }()
+);
+var serialize = SuperJSON.serialize;
+var deserialize = SuperJSON.deserialize;
+var stringify = SuperJSON.stringify;
+var parse = SuperJSON.parse;
+var registerClass = SuperJSON.registerClass;
+var registerCustom = SuperJSON.registerCustom;
+var registerSymbol = SuperJSON.registerSymbol;
+var allowErrorProps = SuperJSON.allowErrorProps;
+
+// src/utils.tsx
+function getQueryStatusLabel(query) {
+  return query.state.fetchStatus === "fetching" ? "fetching" : !query.getObserversCount() ? "inactive" : query.state.fetchStatus === "paused" ? "paused" : query.isStale() ? "stale" : "fresh";
+}
+function getSidedProp(prop, side) {
+  return `${prop}${side.charAt(0).toUpperCase() + side.slice(1)}`;
+}
+function getQueryStatusColor({
+  queryState,
+  observerCount,
+  isStale
+}) {
+  return queryState.fetchStatus === "fetching" ? "blue" : !observerCount ? "gray" : queryState.fetchStatus === "paused" ? "purple" : isStale ? "yellow" : "green";
+}
+function getMutationStatusColor({
+  status,
+  isPaused
+}) {
+  return isPaused ? "purple" : status === "error" ? "red" : status === "pending" ? "yellow" : status === "success" ? "green" : "gray";
+}
+function getQueryStatusColorByLabel(label) {
+  return label === "fresh" ? "green" : label === "stale" ? "yellow" : label === "paused" ? "purple" : label === "inactive" ? "gray" : "blue";
+}
+var displayValue = (value, beautify = false) => {
+  const { json } = serialize(value);
+  return JSON.stringify(json, null, beautify ? 2 : void 0);
+};
+var getStatusRank = (q) => q.state.fetchStatus !== "idle" ? 0 : !q.getObserversCount() ? 3 : q.isStale() ? 2 : 1;
+var queryHashSort = (a, b) => a.queryHash.localeCompare(b.queryHash);
+var dateSort = (a, b) => a.state.dataUpdatedAt < b.state.dataUpdatedAt ? 1 : -1;
+var statusAndDateSort = (a, b) => {
+  if (getStatusRank(a) === getStatusRank(b)) {
+    return dateSort(a, b);
+  }
+  return getStatusRank(a) > getStatusRank(b) ? 1 : -1;
+};
+var sortFns = {
+  status: statusAndDateSort,
+  "query hash": queryHashSort,
+  "last updated": dateSort
+};
+var getMutationStatusRank = (m) => m.state.isPaused ? 0 : m.state.status === "error" ? 2 : m.state.status === "pending" ? 1 : 3;
+var mutationDateSort = (a, b) => a.state.submittedAt < b.state.submittedAt ? 1 : -1;
+var mutationStatusSort = (a, b) => {
+  if (getMutationStatusRank(a) === getMutationStatusRank(b)) {
+    return mutationDateSort(a, b);
+  }
+  return getMutationStatusRank(a) > getMutationStatusRank(b) ? 1 : -1;
+};
+var mutationSortFns = {
+  status: mutationStatusSort,
+  "last updated": mutationDateSort
+};
+var convertRemToPixels = (rem) => {
+  return rem * parseFloat(getComputedStyle(document.documentElement).fontSize);
+};
+var getPreferredColorScheme = () => {
+  const [colorScheme, setColorScheme] = createSignal("dark");
+  onMount(() => {
+    const query = window.matchMedia("(prefers-color-scheme: dark)");
+    setColorScheme(query.matches ? "dark" : "light");
+    const listener = (e) => {
+      setColorScheme(e.matches ? "dark" : "light");
+    };
+    query.addEventListener("change", listener);
+    onCleanup(() => query.removeEventListener("change", listener));
+  });
+  return colorScheme;
+};
+var updateNestedDataByPath = (oldData, updatePath, value) => {
+  if (updatePath.length === 0) {
+    return value;
+  }
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (updatePath.length === 1) {
+      newData.set(updatePath[0], value);
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData.set(head, updateNestedDataByPath(newData.get(head), tail, value));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = updateNestedDataByPath(
+      Array.from(oldData),
+      updatePath,
+      value
+    );
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (updatePath.length === 1) {
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = { ...oldData };
+    if (updatePath.length === 1) {
+      newData[updatePath[0]] = value;
+      return newData;
+    }
+    const [head, ...tail] = updatePath;
+    newData[head] = updateNestedDataByPath(newData[head], tail, value);
+    return newData;
+  }
+  return oldData;
+};
+var deleteNestedDataByPath = (oldData, deletePath) => {
+  if (oldData instanceof Map) {
+    const newData = new Map(oldData);
+    if (deletePath.length === 1) {
+      newData.delete(deletePath[0]);
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
+    return newData;
+  }
+  if (oldData instanceof Set) {
+    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
+    return new Set(setAsArray);
+  }
+  if (Array.isArray(oldData)) {
+    const newData = [...oldData];
+    if (deletePath.length === 1) {
+      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
+    }
+    const [head, ...tail] = deletePath;
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  if (oldData instanceof Object) {
+    const newData = { ...oldData };
+    if (deletePath.length === 1) {
+      delete newData[deletePath[0]];
+      return newData;
+    }
+    const [head, ...tail] = deletePath;
+    newData[head] = deleteNestedDataByPath(newData[head], tail);
+    return newData;
+  }
+  return oldData;
+};
+var setupStyleSheet = (nonce) => {
+  if (!nonce)
+    return;
+  const styleExists = document.querySelector("#_goober");
+  if (styleExists)
+    return;
+  const styleTag = document.createElement("style");
+  const textNode = document.createTextNode("");
+  styleTag.appendChild(textNode);
+  styleTag.id = "_goober";
+  styleTag.setAttribute("nonce", nonce);
+  document.head.appendChild(styleTag);
+};
+
 export {
   $PROXY,
   $TRACK,
@@ -2071,5 +3276,19 @@ export {
   use,
   isServer,
   Portal,
-  Dynamic
+  Dynamic,
+  stringify,
+  getQueryStatusLabel,
+  getSidedProp,
+  getQueryStatusColor,
+  getMutationStatusColor,
+  getQueryStatusColorByLabel,
+  displayValue,
+  sortFns,
+  mutationSortFns,
+  convertRemToPixels,
+  getPreferredColorScheme,
+  updateNestedDataByPath,
+  deleteNestedDataByPath,
+  setupStyleSheet
 };