@tonyclaw/agent-inspector 3.0.44 → 3.0.46

package/.output/server/_libs/trim-lines.mjs

@@ -1,41 +0,0 @@
-const tab = 9;
-const space = 32;
-function trimLines(value) {
-  const source = String(value);
-  const search = /\r?\n|\r/g;
-  let match = search.exec(source);
-  let last = 0;
-  const lines = [];
-  while (match) {
-    lines.push(
-      trimLine(source.slice(last, match.index), last > 0, true),
-      match[0]
-    );
-    last = match.index + match[0].length;
-    match = search.exec(source);
-  }
-  lines.push(trimLine(source.slice(last), last > 0, false));
-  return lines.join("");
-}
-function trimLine(value, start, end) {
-  let startIndex = 0;
-  let endIndex = value.length;
-  if (start) {
-    let code = value.codePointAt(startIndex);
-    while (code === tab || code === space) {
-      startIndex++;
-      code = value.codePointAt(startIndex);
-    }
-  }
-  if (end) {
-    let code = value.codePointAt(endIndex - 1);
-    while (code === tab || code === space) {
-      endIndex--;
-      code = value.codePointAt(endIndex - 1);
-    }
-  }
-  return endIndex > startIndex ? value.slice(startIndex, endIndex) : "";
-}
-export {
-  trimLines as t
-};

package/.output/server/_libs/trough.mjs

@@ -1,85 +0,0 @@
-function trough() {
-  const fns = [];
-  const pipeline = { run, use };
-  return pipeline;
-  function run(...values) {
-    let middlewareIndex = -1;
-    const callback = values.pop();
-    if (typeof callback !== "function") {
-      throw new TypeError("Expected function as last argument, not " + callback);
-    }
-    next(null, ...values);
-    function next(error, ...output) {
-      const fn = fns[++middlewareIndex];
-      let index = -1;
-      if (error) {
-        callback(error);
-        return;
-      }
-      while (++index < values.length) {
-        if (output[index] === null || output[index] === void 0) {
-          output[index] = values[index];
-        }
-      }
-      values = output;
-      if (fn) {
-        wrap(fn, next)(...output);
-      } else {
-        callback(null, ...output);
-      }
-    }
-  }
-  function use(middelware) {
-    if (typeof middelware !== "function") {
-      throw new TypeError(
-        "Expected `middelware` to be a function, not " + middelware
-      );
-    }
-    fns.push(middelware);
-    return pipeline;
-  }
-}
-function wrap(middleware, callback) {
-  let called;
-  return wrapped;
-  function wrapped(...parameters) {
-    const fnExpectsCallback = middleware.length > parameters.length;
-    let result;
-    if (fnExpectsCallback) {
-      parameters.push(done);
-    }
-    try {
-      result = middleware.apply(this, parameters);
-    } catch (error) {
-      const exception = (
-        /** @type {Error} */
-        error
-      );
-      if (fnExpectsCallback && called) {
-        throw exception;
-      }
-      return done(exception);
-    }
-    if (!fnExpectsCallback) {
-      if (result && result.then && typeof result.then === "function") {
-        result.then(then, done);
-      } else if (result instanceof Error) {
-        done(result);
-      } else {
-        then(result);
-      }
-    }
-  }
-  function done(error, ...output) {
-    if (!called) {
-      called = true;
-      callback(error, ...output);
-    }
-  }
-  function then(value) {
-    done(null, value);
-  }
-}
-export {
-  trough as t
-};

package/.output/server/_libs/tslib.mjs

@@ -1 +0,0 @@
-

package/.output/server/_libs/ungap__structured-clone.mjs

@@ -1,212 +0,0 @@
-const VOID = -1;
-const PRIMITIVE = 0;
-const ARRAY = 1;
-const OBJECT = 2;
-const DATE = 3;
-const REGEXP = 4;
-const MAP = 5;
-const SET = 6;
-const ERROR = 7;
-const BIGINT = 8;
-const env = typeof self === "object" ? self : globalThis;
-const deserializer = ($, _) => {
-  const as = (out, index) => {
-    $.set(index, out);
-    return out;
-  };
-  const unpair = (index) => {
-    if ($.has(index))
-      return $.get(index);
-    const [type, value] = _[index];
-    switch (type) {
-      case PRIMITIVE:
-      case VOID:
-        return as(value, index);
-      case ARRAY: {
-        const arr = as([], index);
-        for (const index2 of value)
-          arr.push(unpair(index2));
-        return arr;
-      }
-      case OBJECT: {
-        const object = as({}, index);
-        for (const [key, index2] of value)
-          object[unpair(key)] = unpair(index2);
-        return object;
-      }
-      case DATE:
-        return as(new Date(value), index);
-      case REGEXP: {
-        const { source, flags } = value;
-        return as(new RegExp(source, flags), index);
-      }
-      case MAP: {
-        const map = as(/* @__PURE__ */ new Map(), index);
-        for (const [key, index2] of value)
-          map.set(unpair(key), unpair(index2));
-        return map;
-      }
-      case SET: {
-        const set = as(/* @__PURE__ */ new Set(), index);
-        for (const index2 of value)
-          set.add(unpair(index2));
-        return set;
-      }
-      case ERROR: {
-        const { name, message } = value;
-        return as(new env[name](message), index);
-      }
-      case BIGINT:
-        return as(BigInt(value), index);
-      case "BigInt":
-        return as(Object(BigInt(value)), index);
-      case "ArrayBuffer":
-        return as(new Uint8Array(value).buffer, value);
-      case "DataView": {
-        const { buffer } = new Uint8Array(value);
-        return as(new DataView(buffer), value);
-      }
-    }
-    return as(new env[type](value), index);
-  };
-  return unpair;
-};
-const deserialize = (serialized) => deserializer(/* @__PURE__ */ new Map(), serialized)(0);
-const EMPTY = "";
-const { toString } = {};
-const { keys } = Object;
-const typeOf = (value) => {
-  const type = typeof value;
-  if (type !== "object" || !value)
-    return [PRIMITIVE, type];
-  const asString = toString.call(value).slice(8, -1);
-  switch (asString) {
-    case "Array":
-      return [ARRAY, EMPTY];
-    case "Object":
-      return [OBJECT, EMPTY];
-    case "Date":
-      return [DATE, EMPTY];
-    case "RegExp":
-      return [REGEXP, EMPTY];
-    case "Map":
-      return [MAP, EMPTY];
-    case "Set":
-      return [SET, EMPTY];
-    case "DataView":
-      return [ARRAY, asString];
-  }
-  if (asString.includes("Array"))
-    return [ARRAY, asString];
-  if (asString.includes("Error"))
-    return [ERROR, asString];
-  return [OBJECT, asString];
-};
-const shouldSkip = ([TYPE, type]) => TYPE === PRIMITIVE && (type === "function" || type === "symbol");
-const serializer = (strict, json, $, _) => {
-  const as = (out, value) => {
-    const index = _.push(out) - 1;
-    $.set(value, index);
-    return index;
-  };
-  const pair = (value) => {
-    if ($.has(value))
-      return $.get(value);
-    let [TYPE, type] = typeOf(value);
-    switch (TYPE) {
-      case PRIMITIVE: {
-        let entry = value;
-        switch (type) {
-          case "bigint":
-            TYPE = BIGINT;
-            entry = value.toString();
-            break;
-          case "function":
-          case "symbol":
-            if (strict)
-              throw new TypeError("unable to serialize " + type);
-            entry = null;
-            break;
-          case "undefined":
-            return as([VOID], value);
-        }
-        return as([TYPE, entry], value);
-      }
-      case ARRAY: {
-        if (type) {
-          let spread = value;
-          if (type === "DataView") {
-            spread = new Uint8Array(value.buffer);
-          } else if (type === "ArrayBuffer") {
-            spread = new Uint8Array(value);
-          }
-          return as([type, [...spread]], value);
-        }
-        const arr = [];
-        const index = as([TYPE, arr], value);
-        for (const entry of value)
-          arr.push(pair(entry));
-        return index;
-      }
-      case OBJECT: {
-        if (type) {
-          switch (type) {
-            case "BigInt":
-              return as([type, value.toString()], value);
-            case "Boolean":
-            case "Number":
-            case "String":
-              return as([type, value.valueOf()], value);
-          }
-        }
-        if (json && "toJSON" in value)
-          return pair(value.toJSON());
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const key of keys(value)) {
-          if (strict || !shouldSkip(typeOf(value[key])))
-            entries.push([pair(key), pair(value[key])]);
-        }
-        return index;
-      }
-      case DATE:
-        return as([TYPE, value.toISOString()], value);
-      case REGEXP: {
-        const { source, flags } = value;
-        return as([TYPE, { source, flags }], value);
-      }
-      case MAP: {
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const [key, entry] of value) {
-          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))
-            entries.push([pair(key), pair(entry)]);
-        }
-        return index;
-      }
-      case SET: {
-        const entries = [];
-        const index = as([TYPE, entries], value);
-        for (const entry of value) {
-          if (strict || !shouldSkip(typeOf(entry)))
-            entries.push(pair(entry));
-        }
-        return index;
-      }
-    }
-    const { message } = value;
-    return as([TYPE, { name: type, message }], value);
-  };
-  return pair;
-};
-const serialize = (value, { json, lossy } = {}) => {
-  const _ = [];
-  return serializer(!(json || lossy), !!json, /* @__PURE__ */ new Map(), _)(value), _;
-};
-const structuredClone$1 = typeof structuredClone === "function" ? (
-  /* c8 ignore start */
-  (any, options) => options && ("json" in options || "lossy" in options) ? deserialize(serialize(any, options)) : structuredClone(any)
-) : (any, options) => deserialize(serialize(any, options));
-export {
-  structuredClone$1 as s
-};