@redscope-ai/redscope 1.0.0

package/dist/chunk-v4ypszbb.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/bundledMode.ts
+function isRunningWithBun() {
+  return process.versions.bun !== undefined;
+}
+function isInBundledMode() {
+  return typeof Bun !== "undefined" && Array.isArray(Bun.embeddedFiles) && Bun.embeddedFiles.length > 0;
+}
+var init_bundledMode = () => {};
+
+export { isRunningWithBun, isInBundledMode, init_bundledMode };

package/dist/chunk-v7wbqcx9.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  __commonJS,
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@smithy+is-array-buffer@4.2.2/node_modules/@smithy/is-array-buffer/dist-cjs/index.js
+var require_dist_cjs = __commonJS((exports) => {
+  var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
+  exports.isArrayBuffer = isArrayBuffer;
+});
+
+// node_modules/.bun/@smithy+util-buffer-from@4.2.2/node_modules/@smithy/util-buffer-from/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var isArrayBuffer = require_dist_cjs();
+  var buffer = __require("buffer");
+  var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
+    if (!isArrayBuffer.isArrayBuffer(input)) {
+      throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
+    }
+    return buffer.Buffer.from(input, offset, length);
+  };
+  var fromString = (input, encoding) => {
+    if (typeof input !== "string") {
+      throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
+    }
+    return encoding ? buffer.Buffer.from(input, encoding) : buffer.Buffer.from(input);
+  };
+  exports.fromArrayBuffer = fromArrayBuffer;
+  exports.fromString = fromString;
+});
+
+// node_modules/.bun/@smithy+util-utf8@4.2.2/node_modules/@smithy/util-utf8/dist-cjs/index.js
+var require_dist_cjs3 = __commonJS((exports) => {
+  var utilBufferFrom = require_dist_cjs2();
+  var fromUtf8 = (input) => {
+    const buf = utilBufferFrom.fromString(input, "utf8");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+  };
+  var toUint8Array = (data) => {
+    if (typeof data === "string") {
+      return fromUtf8(data);
+    }
+    if (ArrayBuffer.isView(data)) {
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
+    }
+    return new Uint8Array(data);
+  };
+  var toUtf8 = (input) => {
+    if (typeof input === "string") {
+      return input;
+    }
+    if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
+      throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
+    }
+    return utilBufferFrom.fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
+  };
+  exports.fromUtf8 = fromUtf8;
+  exports.toUint8Array = toUint8Array;
+  exports.toUtf8 = toUtf8;
+});
+
+export { require_dist_cjs, require_dist_cjs2 as require_dist_cjs1, require_dist_cjs3 as require_dist_cjs2 };

package/dist/chunk-v8r5fev3.js

@@ -0,0 +1,341 @@
+// @bun
+import {
+  __commonJS,
+  __require
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      if (isLinux() && process.report) {
+        const orig = process.report.excludeNetwork;
+        process.report.excludeNetwork = true;
+        report = process.report.getReport();
+        process.report.excludeNetwork = orig;
+      } else {
+        report = {};
+      }
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
+});
+
+// node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var LDD_PATH = "/usr/bin/ldd";
+  var SELF_PATH = "/proc/self/exe";
+  var MAX_LENGTH = 2048;
+  var readFileSync = (path) => {
+    const fd = fs.openSync(path, "r");
+    const buffer = Buffer.alloc(MAX_LENGTH);
+    const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+    fs.close(fd, () => {});
+    return buffer.subarray(0, bytesRead);
+  };
+  var readFile = (path) => new Promise((resolve, reject) => {
+    fs.open(path, "r", (err, fd) => {
+      if (err) {
+        reject(err);
+      } else {
+        const buffer = Buffer.alloc(MAX_LENGTH);
+        fs.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          resolve(buffer.subarray(0, bytesRead));
+          fs.close(fd, () => {});
+        });
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    SELF_PATH,
+    readFileSync,
+    readFile
+  };
+});
+
+// node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS((exports, module) => {
+  var interpreterPath = (elf) => {
+    if (elf.length < 64) {
+      return null;
+    }
+    if (elf.readUInt32BE(0) !== 2135247942) {
+      return null;
+    }
+    if (elf.readUInt8(4) !== 2) {
+      return null;
+    }
+    if (elf.readUInt8(5) !== 1) {
+      return null;
+    }
+    const offset = elf.readUInt32LE(32);
+    const size = elf.readUInt16LE(54);
+    const count = elf.readUInt16LE(56);
+    for (let i = 0;i < count; i++) {
+      const headerOffset = offset + i * size;
+      const type = elf.readUInt32LE(headerOffset);
+      if (type === 3) {
+        const fileOffset = elf.readUInt32LE(headerOffset + 8);
+        const fileSize = elf.readUInt32LE(headerOffset + 32);
+        return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+      }
+    }
+    return null;
+  };
+  module.exports = {
+    interpreterPath
+  };
+});
+
+// node_modules/.bun/detect-libc@2.1.2/node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS((exports, module) => {
+  var childProcess = __require("child_process");
+  var { isLinux, getReport } = require_process();
+  var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
+  var { interpreterPath } = require_elf();
+  var cachedFamilyInterpreter;
+  var cachedFamilyFilesystem;
+  var cachedVersionFilesystem;
+  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+  var commandOut = "";
+  var safeCommand = () => {
+    if (!commandOut) {
+      return new Promise((resolve) => {
+        childProcess.exec(command, (err, out) => {
+          commandOut = err ? " " : out;
+          resolve(commandOut);
+        });
+      });
+    }
+    return commandOut;
+  };
+  var safeCommandSync = () => {
+    if (!commandOut) {
+      try {
+        commandOut = childProcess.execSync(command, { encoding: "utf8" });
+      } catch (_err) {
+        commandOut = " ";
+      }
+    }
+    return commandOut;
+  };
+  var GLIBC = "glibc";
+  var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+  var MUSL = "musl";
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var familyFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return GLIBC;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return MUSL;
+      }
+    }
+    return null;
+  };
+  var familyFromCommand = (out) => {
+    const [getconf, ldd1] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return GLIBC;
+    }
+    if (ldd1 && ldd1.includes(MUSL)) {
+      return MUSL;
+    }
+    return null;
+  };
+  var familyFromInterpreterPath = (path) => {
+    if (path) {
+      if (path.includes("/ld-musl-")) {
+        return MUSL;
+      } else if (path.includes("/ld-linux-")) {
+        return GLIBC;
+      }
+    }
+    return null;
+  };
+  var getFamilyFromLddContent = (content) => {
+    content = content.toString();
+    if (content.includes("musl")) {
+      return MUSL;
+    }
+    if (content.includes("GNU C Library")) {
+      return GLIBC;
+    }
+    return null;
+  };
+  var familyFromFilesystem = async () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromFilesystemSync = () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = readFileSync(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
+  };
+  var familyFromInterpreter = async () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = await readFile(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var familyFromInterpreterSync = () => {
+    if (cachedFamilyInterpreter !== undefined) {
+      return cachedFamilyInterpreter;
+    }
+    cachedFamilyInterpreter = null;
+    try {
+      const selfContent = readFileSync(SELF_PATH);
+      const path = interpreterPath(selfContent);
+      cachedFamilyInterpreter = familyFromInterpreterPath(path);
+    } catch (e) {}
+    return cachedFamilyInterpreter;
+  };
+  var family = async () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = await familyFromInterpreter();
+      if (!family2) {
+        family2 = await familyFromFilesystem();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = await safeCommand();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var familySync = () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = familyFromInterpreterSync();
+      if (!family2) {
+        family2 = familyFromFilesystemSync();
+        if (!family2) {
+          family2 = familyFromReport();
+        }
+        if (!family2) {
+          const out = safeCommandSync();
+          family2 = familyFromCommand(out);
+        }
+      }
+    }
+    return family2;
+  };
+  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+  var versionFromFilesystem = async () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromFilesystemSync = () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = readFileSync(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
+      }
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return report.header.glibcVersionRuntime;
+    }
+    return null;
+  };
+  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+  var versionFromCommand = (out) => {
+    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return versionSuffix(getconf);
+    }
+    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+      return versionSuffix(ldd2);
+    }
+    return null;
+  };
+  var version = async () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = await versionFromFilesystem();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  var versionSync = () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = versionFromFilesystemSync();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
+  };
+  module.exports = {
+    GLIBC,
+    MUSL,
+    family,
+    familySync,
+    isNonGlibcLinux,
+    isNonGlibcLinuxSync,
+    version,
+    versionSync
+  };
+});
+
+export { require_detect_libc };