@tonyclaw/agent-inspector 3.0.15 → 3.0.17

package/.output/server/_libs/ecdsa-sig-formatter.mjs

@@ -0,0 +1,162 @@
+import { a as requireSafeBuffer } from "./safe-buffer.mjs";
+var paramBytesForAlg_1;
+var hasRequiredParamBytesForAlg;
+function requireParamBytesForAlg() {
+  if (hasRequiredParamBytesForAlg) return paramBytesForAlg_1;
+  hasRequiredParamBytesForAlg = 1;
+  function getParamSize(keySize) {
+    var result = (keySize / 8 | 0) + (keySize % 8 === 0 ? 0 : 1);
+    return result;
+  }
+  var paramBytesForAlg = {
+    ES256: getParamSize(256),
+    ES384: getParamSize(384),
+    ES512: getParamSize(521)
+  };
+  function getParamBytesForAlg(alg) {
+    var paramBytes = paramBytesForAlg[alg];
+    if (paramBytes) {
+      return paramBytes;
+    }
+    throw new Error('Unknown algorithm "' + alg + '"');
+  }
+  paramBytesForAlg_1 = getParamBytesForAlg;
+  return paramBytesForAlg_1;
+}
+var ecdsaSigFormatter;
+var hasRequiredEcdsaSigFormatter;
+function requireEcdsaSigFormatter() {
+  if (hasRequiredEcdsaSigFormatter) return ecdsaSigFormatter;
+  hasRequiredEcdsaSigFormatter = 1;
+  var Buffer = requireSafeBuffer().Buffer;
+  var getParamBytesForAlg = requireParamBytesForAlg();
+  var MAX_OCTET = 128, CLASS_UNIVERSAL = 0, PRIMITIVE_BIT = 32, TAG_SEQ = 16, TAG_INT = 2, ENCODED_TAG_SEQ = TAG_SEQ | PRIMITIVE_BIT | CLASS_UNIVERSAL << 6, ENCODED_TAG_INT = TAG_INT | CLASS_UNIVERSAL << 6;
+  function base64Url(base64) {
+    return base64.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  }
+  function signatureAsBuffer(signature) {
+    if (Buffer.isBuffer(signature)) {
+      return signature;
+    } else if ("string" === typeof signature) {
+      return Buffer.from(signature, "base64");
+    }
+    throw new TypeError("ECDSA signature must be a Base64 string or a Buffer");
+  }
+  function derToJose(signature, alg) {
+    signature = signatureAsBuffer(signature);
+    var paramBytes = getParamBytesForAlg(alg);
+    var maxEncodedParamLength = paramBytes + 1;
+    var inputLength = signature.length;
+    var offset = 0;
+    if (signature[offset++] !== ENCODED_TAG_SEQ) {
+      throw new Error('Could not find expected "seq"');
+    }
+    var seqLength = signature[offset++];
+    if (seqLength === (MAX_OCTET | 1)) {
+      seqLength = signature[offset++];
+    }
+    if (inputLength - offset < seqLength) {
+      throw new Error('"seq" specified length of "' + seqLength + '", only "' + (inputLength - offset) + '" remaining');
+    }
+    if (signature[offset++] !== ENCODED_TAG_INT) {
+      throw new Error('Could not find expected "int" for "r"');
+    }
+    var rLength = signature[offset++];
+    if (inputLength - offset - 2 < rLength) {
+      throw new Error('"r" specified length of "' + rLength + '", only "' + (inputLength - offset - 2) + '" available');
+    }
+    if (maxEncodedParamLength < rLength) {
+      throw new Error('"r" specified length of "' + rLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
+    }
+    var rOffset = offset;
+    offset += rLength;
+    if (signature[offset++] !== ENCODED_TAG_INT) {
+      throw new Error('Could not find expected "int" for "s"');
+    }
+    var sLength = signature[offset++];
+    if (inputLength - offset !== sLength) {
+      throw new Error('"s" specified length of "' + sLength + '", expected "' + (inputLength - offset) + '"');
+    }
+    if (maxEncodedParamLength < sLength) {
+      throw new Error('"s" specified length of "' + sLength + '", max of "' + maxEncodedParamLength + '" is acceptable');
+    }
+    var sOffset = offset;
+    offset += sLength;
+    if (offset !== inputLength) {
+      throw new Error('Expected to consume entire buffer, but "' + (inputLength - offset) + '" bytes remain');
+    }
+    var rPadding = paramBytes - rLength, sPadding = paramBytes - sLength;
+    var dst = Buffer.allocUnsafe(rPadding + rLength + sPadding + sLength);
+    for (offset = 0; offset < rPadding; ++offset) {
+      dst[offset] = 0;
+    }
+    signature.copy(dst, offset, rOffset + Math.max(-rPadding, 0), rOffset + rLength);
+    offset = paramBytes;
+    for (var o = offset; offset < o + sPadding; ++offset) {
+      dst[offset] = 0;
+    }
+    signature.copy(dst, offset, sOffset + Math.max(-sPadding, 0), sOffset + sLength);
+    dst = dst.toString("base64");
+    dst = base64Url(dst);
+    return dst;
+  }
+  function countPadding(buf, start, stop) {
+    var padding = 0;
+    while (start + padding < stop && buf[start + padding] === 0) {
+      ++padding;
+    }
+    var needsSign = buf[start + padding] >= MAX_OCTET;
+    if (needsSign) {
+      --padding;
+    }
+    return padding;
+  }
+  function joseToDer(signature, alg) {
+    signature = signatureAsBuffer(signature);
+    var paramBytes = getParamBytesForAlg(alg);
+    var signatureBytes = signature.length;
+    if (signatureBytes !== paramBytes * 2) {
+      throw new TypeError('"' + alg + '" signatures must be "' + paramBytes * 2 + '" bytes, saw "' + signatureBytes + '"');
+    }
+    var rPadding = countPadding(signature, 0, paramBytes);
+    var sPadding = countPadding(signature, paramBytes, signature.length);
+    var rLength = paramBytes - rPadding;
+    var sLength = paramBytes - sPadding;
+    var rsBytes = 1 + 1 + rLength + 1 + 1 + sLength;
+    var shortLength = rsBytes < MAX_OCTET;
+    var dst = Buffer.allocUnsafe((shortLength ? 2 : 3) + rsBytes);
+    var offset = 0;
+    dst[offset++] = ENCODED_TAG_SEQ;
+    if (shortLength) {
+      dst[offset++] = rsBytes;
+    } else {
+      dst[offset++] = MAX_OCTET | 1;
+      dst[offset++] = rsBytes & 255;
+    }
+    dst[offset++] = ENCODED_TAG_INT;
+    dst[offset++] = rLength;
+    if (rPadding < 0) {
+      dst[offset++] = 0;
+      offset += signature.copy(dst, offset, 0, paramBytes);
+    } else {
+      offset += signature.copy(dst, offset, rPadding, paramBytes);
+    }
+    dst[offset++] = ENCODED_TAG_INT;
+    dst[offset++] = sLength;
+    if (sPadding < 0) {
+      dst[offset++] = 0;
+      signature.copy(dst, offset, paramBytes);
+    } else {
+      signature.copy(dst, offset, paramBytes + sPadding);
+    }
+    return dst;
+  }
+  ecdsaSigFormatter = {
+    derToJose,
+    joseToDer
+  };
+  return ecdsaSigFormatter;
+}
+export {
+  requireEcdsaSigFormatter as r
+};

package/.output/server/_libs/extend.mjs

@@ -93,5 +93,6 @@ function requireExtend() {
 var extendExports = requireExtend();
 const extend = /* @__PURE__ */ getDefaultExportFromCjs(extendExports);
 export {
-  extend as e
+  extend as e,
+  requireExtend as r
 };

package/.output/server/_libs/fetch-blob.mjs

@@ -0,0 +1,287 @@
+import { promises } from "node:fs";
+import "node:path";
+import "./node-domexception.mjs";
+import { r as requirePonyfill_es2018 } from "./web-streams-polyfill.mjs";
+var streams = {};
+var hasRequiredStreams;
+function requireStreams() {
+  if (hasRequiredStreams) return streams;
+  hasRequiredStreams = 1;
+  const POOL_SIZE2 = 65536;
+  if (!globalThis.ReadableStream) {
+    try {
+      const process = require("node:process");
+      const { emitWarning } = process;
+      try {
+        process.emitWarning = () => {
+        };
+        Object.assign(globalThis, require("node:stream/web"));
+        process.emitWarning = emitWarning;
+      } catch (error) {
+        process.emitWarning = emitWarning;
+        throw error;
+      }
+    } catch (error) {
+      Object.assign(globalThis, requirePonyfill_es2018());
+    }
+  }
+  try {
+    const { Blob: Blob3 } = require("buffer");
+    if (Blob3 && !Blob3.prototype.stream) {
+      Blob3.prototype.stream = function name(params) {
+        let position = 0;
+        const blob = this;
+        return new ReadableStream({
+          type: "bytes",
+          async pull(ctrl) {
+            const chunk = blob.slice(position, Math.min(blob.size, position + POOL_SIZE2));
+            const buffer = await chunk.arrayBuffer();
+            position += buffer.byteLength;
+            ctrl.enqueue(new Uint8Array(buffer));
+            if (position === blob.size) {
+              ctrl.close();
+            }
+          }
+        });
+      };
+    }
+  } catch (error) {
+  }
+  return streams;
+}
+requireStreams();
+const POOL_SIZE = 65536;
+async function* toIterator(parts, clone = true) {
+  for (const part of parts) {
+    if ("stream" in part) {
+      yield* (
+        /** @type {AsyncIterableIterator<Uint8Array>} */
+        part.stream()
+      );
+    } else if (ArrayBuffer.isView(part)) {
+      if (clone) {
+        let position = part.byteOffset;
+        const end = part.byteOffset + part.byteLength;
+        while (position !== end) {
+          const size = Math.min(end - position, POOL_SIZE);
+          const chunk = part.buffer.slice(position, position + size);
+          position += chunk.byteLength;
+          yield new Uint8Array(chunk);
+        }
+      } else {
+        yield part;
+      }
+    } else {
+      let position = 0, b = (
+        /** @type {Blob} */
+        part
+      );
+      while (position !== b.size) {
+        const chunk = b.slice(position, Math.min(b.size, position + POOL_SIZE));
+        const buffer = await chunk.arrayBuffer();
+        position += buffer.byteLength;
+        yield new Uint8Array(buffer);
+      }
+    }
+  }
+}
+const _Blob = class Blob {
+  /** @type {Array.<(Blob|Uint8Array)>} */
+  #parts = [];
+  #type = "";
+  #size = 0;
+  #endings = "transparent";
+  /**
+   * The Blob() constructor returns a new Blob object. The content
+   * of the blob consists of the concatenation of the values given
+   * in the parameter array.
+   *
+   * @param {*} blobParts
+   * @param {{ type?: string, endings?: string }} [options]
+   */
+  constructor(blobParts = [], options = {}) {
+    if (typeof blobParts !== "object" || blobParts === null) {
+      throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
+    }
+    if (typeof blobParts[Symbol.iterator] !== "function") {
+      throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
+    }
+    if (typeof options !== "object" && typeof options !== "function") {
+      throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
+    }
+    if (options === null) options = {};
+    const encoder = new TextEncoder();
+    for (const element of blobParts) {
+      let part;
+      if (ArrayBuffer.isView(element)) {
+        part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
+      } else if (element instanceof ArrayBuffer) {
+        part = new Uint8Array(element.slice(0));
+      } else if (element instanceof Blob) {
+        part = element;
+      } else {
+        part = encoder.encode(`${element}`);
+      }
+      this.#size += ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      this.#parts.push(part);
+    }
+    this.#endings = `${options.endings === void 0 ? "transparent" : options.endings}`;
+    const type = options.type === void 0 ? "" : String(options.type);
+    this.#type = /^[\x20-\x7E]*$/.test(type) ? type : "";
+  }
+  /**
+   * The Blob interface's size property returns the
+   * size of the Blob in bytes.
+   */
+  get size() {
+    return this.#size;
+  }
+  /**
+   * The type property of a Blob object returns the MIME type of the file.
+   */
+  get type() {
+    return this.#type;
+  }
+  /**
+   * The text() method in the Blob interface returns a Promise
+   * that resolves with a string containing the contents of
+   * the blob, interpreted as UTF-8.
+   *
+   * @return {Promise<string>}
+   */
+  async text() {
+    const decoder = new TextDecoder();
+    let str = "";
+    for await (const part of toIterator(this.#parts, false)) {
+      str += decoder.decode(part, { stream: true });
+    }
+    str += decoder.decode();
+    return str;
+  }
+  /**
+   * The arrayBuffer() method in the Blob interface returns a
+   * Promise that resolves with the contents of the blob as
+   * binary data contained in an ArrayBuffer.
+   *
+   * @return {Promise<ArrayBuffer>}
+   */
+  async arrayBuffer() {
+    const data = new Uint8Array(this.size);
+    let offset = 0;
+    for await (const chunk of toIterator(this.#parts, false)) {
+      data.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return data.buffer;
+  }
+  stream() {
+    const it = toIterator(this.#parts, true);
+    return new globalThis.ReadableStream({
+      // @ts-ignore
+      type: "bytes",
+      async pull(ctrl) {
+        const chunk = await it.next();
+        chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
+      },
+      async cancel() {
+        await it.return();
+      }
+    });
+  }
+  /**
+   * The Blob interface's slice() method creates and returns a
+   * new Blob object which contains data from a subset of the
+   * blob on which it's called.
+   *
+   * @param {number} [start]
+   * @param {number} [end]
+   * @param {string} [type]
+   */
+  slice(start = 0, end = this.size, type = "") {
+    const { size } = this;
+    let relativeStart = start < 0 ? Math.max(size + start, 0) : Math.min(start, size);
+    let relativeEnd = end < 0 ? Math.max(size + end, 0) : Math.min(end, size);
+    const span = Math.max(relativeEnd - relativeStart, 0);
+    const parts = this.#parts;
+    const blobParts = [];
+    let added = 0;
+    for (const part of parts) {
+      if (added >= span) {
+        break;
+      }
+      const size2 = ArrayBuffer.isView(part) ? part.byteLength : part.size;
+      if (relativeStart && size2 <= relativeStart) {
+        relativeStart -= size2;
+        relativeEnd -= size2;
+      } else {
+        let chunk;
+        if (ArrayBuffer.isView(part)) {
+          chunk = part.subarray(relativeStart, Math.min(size2, relativeEnd));
+          added += chunk.byteLength;
+        } else {
+          chunk = part.slice(relativeStart, Math.min(size2, relativeEnd));
+          added += chunk.size;
+        }
+        relativeEnd -= size2;
+        blobParts.push(chunk);
+        relativeStart = 0;
+      }
+    }
+    const blob = new Blob([], { type: String(type).toLowerCase() });
+    blob.#size = span;
+    blob.#parts = blobParts;
+    return blob;
+  }
+  get [Symbol.toStringTag]() {
+    return "Blob";
+  }
+  static [Symbol.hasInstance](object) {
+    return object && typeof object === "object" && typeof object.constructor === "function" && (typeof object.stream === "function" || typeof object.arrayBuffer === "function") && /^(Blob|File)$/.test(object[Symbol.toStringTag]);
+  }
+};
+Object.defineProperties(_Blob.prototype, {
+  size: { enumerable: true },
+  type: { enumerable: true },
+  slice: { enumerable: true }
+});
+const Blob2 = _Blob;
+const _File = class File extends Blob2 {
+  #lastModified = 0;
+  #name = "";
+  /**
+   * @param {*[]} fileBits
+   * @param {string} fileName
+   * @param {{lastModified?: number, type?: string}} options
+   */
+  // @ts-ignore
+  constructor(fileBits, fileName, options = {}) {
+    if (arguments.length < 2) {
+      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
+    }
+    super(fileBits, options);
+    if (options === null) options = {};
+    const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
+    if (!Number.isNaN(lastModified)) {
+      this.#lastModified = lastModified;
+    }
+    this.#name = String(fileName);
+  }
+  get name() {
+    return this.#name;
+  }
+  get lastModified() {
+    return this.#lastModified;
+  }
+  get [Symbol.toStringTag]() {
+    return "File";
+  }
+  static [Symbol.hasInstance](object) {
+    return !!object && object instanceof Blob2 && /^(File)$/.test(object[Symbol.toStringTag]);
+  }
+};
+const File2 = _File;
+const { stat } = promises;
+export {
+  Blob2 as B,
+  File2 as F
+};

package/.output/server/_libs/formdata-polyfill.mjs

@@ -0,0 +1,88 @@
+import { B as Blob, F as File } from "./fetch-blob.mjs";
+var { toStringTag: t, iterator: i, hasInstance: h } = Symbol, r = Math.random, m = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(","), f = (a, b, c) => (a += "", /^(Blob|File)$/.test(b && b[t]) ? [(c = c !== void 0 ? c + "" : b[t] == "File" ? b.name : "blob", a), b.name !== c || b[t] == "blob" ? new File([b], c, b) : b] : [a, b + ""]), e = (c, f2) => (f2 ? c : c.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22"), x = (n, a, e2) => {
+  if (a.length < e2) {
+    throw new TypeError(`Failed to execute '${n}' on 'FormData': ${e2} arguments required, but only ${a.length} present.`);
+  }
+};
+const FormData = class FormData2 {
+  #d = [];
+  constructor(...a) {
+    if (a.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
+  }
+  get [t]() {
+    return "FormData";
+  }
+  [i]() {
+    return this.entries();
+  }
+  static [h](o) {
+    return o && typeof o === "object" && o[t] === "FormData" && !m.some((m2) => typeof o[m2] != "function");
+  }
+  append(...a) {
+    x("append", arguments, 2);
+    this.#d.push(f(...a));
+  }
+  delete(a) {
+    x("delete", arguments, 1);
+    a += "";
+    this.#d = this.#d.filter(([b]) => b !== a);
+  }
+  get(a) {
+    x("get", arguments, 1);
+    a += "";
+    for (var b = this.#d, l = b.length, c = 0; c < l; c++) if (b[c][0] === a) return b[c][1];
+    return null;
+  }
+  getAll(a, b) {
+    x("getAll", arguments, 1);
+    b = [];
+    a += "";
+    this.#d.forEach((c) => c[0] === a && b.push(c[1]));
+    return b;
+  }
+  has(a) {
+    x("has", arguments, 1);
+    a += "";
+    return this.#d.some((b) => b[0] === a);
+  }
+  forEach(a, b) {
+    x("forEach", arguments, 1);
+    for (var [c, d] of this) a.call(b, d, c, this);
+  }
+  set(...a) {
+    x("set", arguments, 2);
+    var b = [], c = true;
+    a = f(...a);
+    this.#d.forEach((d) => {
+      d[0] === a[0] ? c && (c = !b.push(a)) : b.push(d);
+    });
+    c && b.push(a);
+    this.#d = b;
+  }
+  *entries() {
+    yield* this.#d;
+  }
+  *keys() {
+    for (var [a] of this) yield a;
+  }
+  *values() {
+    for (var [, a] of this) yield a;
+  }
+};
+function formDataToBlob(F, B = Blob) {
+  var b = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c = [], p = `--${b}\r
+Content-Disposition: form-data; name="`;
+  F.forEach((v, n) => typeof v == "string" ? c.push(p + e(n) + `"\r
+\r
+${v.replace(new RegExp("\\r(?!\\n)|(?<!\\r)\\n", "g"), "\r\n")}\r
+`) : c.push(p + e(n) + `"; filename="${e(v.name, 1)}"\r
+Content-Type: ${v.type || "application/octet-stream"}\r
+\r
+`, v, "\r\n"));
+  c.push(`--${b}--`);
+  return new B(c, { type: "multipart/form-data; boundary=" + b });
+}
+export {
+  FormData as F,
+  formDataToBlob as f
+};