@tonyclaw/llm-inspector 1.9.8 → 1.10.0

package/.output/server/_libs/setimmediate.mjs

@@ -1 +1,152 @@
-
+import { c as commonjsGlobal } from "./react.mjs";
+var setImmediate = {};
+var hasRequiredSetImmediate;
+function requireSetImmediate() {
+  if (hasRequiredSetImmediate) return setImmediate;
+  hasRequiredSetImmediate = 1;
+  (function(global, undefined$1) {
+    if (global.setImmediate) {
+      return;
+    }
+    var nextHandle = 1;
+    var tasksByHandle = {};
+    var currentlyRunningATask = false;
+    var doc = global.document;
+    var registerImmediate;
+    function setImmediate2(callback) {
+      if (typeof callback !== "function") {
+        callback = new Function("" + callback);
+      }
+      var args = new Array(arguments.length - 1);
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i + 1];
+      }
+      var task = { callback, args };
+      tasksByHandle[nextHandle] = task;
+      registerImmediate(nextHandle);
+      return nextHandle++;
+    }
+    function clearImmediate(handle) {
+      delete tasksByHandle[handle];
+    }
+    function run(task) {
+      var callback = task.callback;
+      var args = task.args;
+      switch (args.length) {
+        case 0:
+          callback();
+          break;
+        case 1:
+          callback(args[0]);
+          break;
+        case 2:
+          callback(args[0], args[1]);
+          break;
+        case 3:
+          callback(args[0], args[1], args[2]);
+          break;
+        default:
+          callback.apply(undefined$1, args);
+          break;
+      }
+    }
+    function runIfPresent(handle) {
+      if (currentlyRunningATask) {
+        setTimeout(runIfPresent, 0, handle);
+      } else {
+        var task = tasksByHandle[handle];
+        if (task) {
+          currentlyRunningATask = true;
+          try {
+            run(task);
+          } finally {
+            clearImmediate(handle);
+            currentlyRunningATask = false;
+          }
+        }
+      }
+    }
+    function installNextTickImplementation() {
+      registerImmediate = function(handle) {
+        process.nextTick(function() {
+          runIfPresent(handle);
+        });
+      };
+    }
+    function canUsePostMessage() {
+      if (global.postMessage && !global.importScripts) {
+        var postMessageIsAsynchronous = true;
+        var oldOnMessage = global.onmessage;
+        global.onmessage = function() {
+          postMessageIsAsynchronous = false;
+        };
+        global.postMessage("", "*");
+        global.onmessage = oldOnMessage;
+        return postMessageIsAsynchronous;
+      }
+    }
+    function installPostMessageImplementation() {
+      var messagePrefix = "setImmediate$" + Math.random() + "$";
+      var onGlobalMessage = function(event) {
+        if (event.source === global && typeof event.data === "string" && event.data.indexOf(messagePrefix) === 0) {
+          runIfPresent(+event.data.slice(messagePrefix.length));
+        }
+      };
+      if (global.addEventListener) {
+        global.addEventListener("message", onGlobalMessage, false);
+      } else {
+        global.attachEvent("onmessage", onGlobalMessage);
+      }
+      registerImmediate = function(handle) {
+        global.postMessage(messagePrefix + handle, "*");
+      };
+    }
+    function installMessageChannelImplementation() {
+      var channel = new MessageChannel();
+      channel.port1.onmessage = function(event) {
+        var handle = event.data;
+        runIfPresent(handle);
+      };
+      registerImmediate = function(handle) {
+        channel.port2.postMessage(handle);
+      };
+    }
+    function installReadyStateChangeImplementation() {
+      var html = doc.documentElement;
+      registerImmediate = function(handle) {
+        var script = doc.createElement("script");
+        script.onreadystatechange = function() {
+          runIfPresent(handle);
+          script.onreadystatechange = null;
+          html.removeChild(script);
+          script = null;
+        };
+        html.appendChild(script);
+      };
+    }
+    function installSetTimeoutImplementation() {
+      registerImmediate = function(handle) {
+        setTimeout(runIfPresent, 0, handle);
+      };
+    }
+    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);
+    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;
+    if ({}.toString.call(global.process) === "[object process]") {
+      installNextTickImplementation();
+    } else if (canUsePostMessage()) {
+      installPostMessageImplementation();
+    } else if (global.MessageChannel) {
+      installMessageChannelImplementation();
+    } else if (doc && "onreadystatechange" in doc.createElement("script")) {
+      installReadyStateChangeImplementation();
+    } else {
+      installSetTimeoutImplementation();
+    }
+    attachTo.setImmediate = setImmediate2;
+    attachTo.clearImmediate = clearImmediate;
+  })(typeof self === "undefined" ? typeof commonjsGlobal === "undefined" ? setImmediate : commonjsGlobal : self);
+  return setImmediate;
+}
+export {
+  requireSetImmediate as r
+};

package/.output/server/_libs/style-to-js.mjs

@@ -47,8 +47,8 @@ function requireCjs() {
   var __importDefault = cjs && cjs.__importDefault || function(mod) {
     return mod && mod.__esModule ? mod : { "default": mod };
   };
-  var style_to_object_1 = __importDefault(/* @__PURE__ */ requireCjs$1());
-  var utilities_1 = /* @__PURE__ */ requireUtilities();
+  var style_to_object_1 = __importDefault(requireCjs$1());
+  var utilities_1 = requireUtilities();
   function StyleToJS(style, options) {
     var output = {};
     if (!style || typeof style !== "string") {
@@ -65,7 +65,7 @@ function requireCjs() {
   cjs = StyleToJS;
   return cjs;
 }
-var cjsExports = /* @__PURE__ */ requireCjs();
+var cjsExports = requireCjs();
 const styleToJs = /* @__PURE__ */ getDefaultExportFromCjs(cjsExports);
 export {
   styleToJs as s

package/.output/server/_libs/style-to-object.mjs

@@ -9,7 +9,7 @@ function requireCjs() {
   };
   Object.defineProperty(cjs, "__esModule", { value: true });
   cjs.default = StyleToObject;
-  const inline_style_parser_1 = __importDefault(/* @__PURE__ */ requireCjs$1());
+  const inline_style_parser_1 = __importDefault(requireCjs$1());
   function StyleToObject(style, iterator) {
     let styleObject = null;
     if (!style || typeof style !== "string") {

package/.output/server/_libs/swr.mjs

@@ -934,5 +934,6 @@ const SWRConfig = OBJECT.defineProperty(SWRConfig$1, "defaultValue", {
 const useSWR = withArgs(useSWRHandler);
 export {
   SWRConfig as S,
+  useSWRConfig as a,
   useSWR as u
 };