@tonyclaw/agent-inspector 2.0.0

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

@@ -0,0 +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/space-separated-tokens.mjs

@@ -0,0 +1,6 @@
+function stringify(values) {
+  return values.join(" ").trim();
+}
+export {
+  stringify as s
+};