@garuda-agent/garuda 0.0.1 → 0.15.0

package/dist/chunk-3CEPHS4C.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import {
+  cleanText
+} from "./chunk-PZS3V6P3.js";
+
+// src/mcp/oauth.ts
+import { randomBytes } from "crypto";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { createServer } from "http";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { z } from "zod";
+var AUTH_FILE = join(".garuda", "mcp-auth.json");
+var SIGN_IN_TIMEOUT_MS = 3e5;
+var entrySchema = z.object({
+  client: z.record(z.string(), z.unknown()).optional(),
+  tokens: z.record(z.string(), z.unknown()).optional(),
+  port: z.number().int().min(1).max(65535).optional(),
+  /** Where the sign-in happens (authorization server), from discovery (SDK: SEP-2352). */
+  discovery: z.record(z.string(), z.unknown()).optional()
+});
+var fileSchema = z.object({
+  version: z.literal(1),
+  servers: z.record(z.string(), entrySchema).default({})
+});
+var AuthStore = class _AuthStore {
+  constructor(file) {
+    this.file = file;
+  }
+  file;
+  data = { version: 1, servers: {} };
+  static async open(home = homedir()) {
+    const store = new _AuthStore(join(home, AUTH_FILE));
+    try {
+      const parsed = fileSchema.safeParse(JSON.parse(await readFile(store.file, "utf8")));
+      if (parsed.success) store.data = parsed.data;
+    } catch {
+    }
+    return store;
+  }
+  get(key) {
+    return this.data.servers[key] ?? {};
+  }
+  async update(key, patch) {
+    const next = { ...this.get(key) };
+    for (const [k, v] of Object.entries(patch)) {
+      if (v === void 0) delete next[k];
+      else next[k] = v;
+    }
+    this.data.servers[key] = next;
+    await this.save();
+  }
+  /** Remove every entry of a server (all scopes and URLs). Returns how many were removed. */
+  async remove(server) {
+    const keys = Object.keys(this.data.servers).filter((k) => k.split("::")[1] === server);
+    for (const k of keys) delete this.data.servers[k];
+    if (keys.length > 0) await this.save();
+    return keys.length;
+  }
+  hasTokens(key) {
+    return this.get(key).tokens !== void 0;
+  }
+  async save() {
+    await mkdir(dirname(this.file), { recursive: true, mode: 448 });
+    const temp = `${this.file}.${randomBytes(4).toString("hex")}.tmp`;
+    await writeFile(temp, `${JSON.stringify(this.data, null, 2)}
+`, { mode: 384, flag: "wx" });
+    await rename(temp, this.file);
+  }
+};
+function authKey(scope, name, url) {
+  return `${scope}::${name}::${url}`;
+}
+var GarudaOAuthProvider = class {
+  constructor(store, key, port) {
+    this.store = store;
+    this.key = key;
+    this.port = port;
+  }
+  store;
+  key;
+  port;
+  /** Set by the SDK when the user must sign in. */
+  authorizationUrl;
+  verifier;
+  expectedState;
+  get redirectUrl() {
+    return `http://127.0.0.1:${this.port}/callback`;
+  }
+  get clientMetadata() {
+    return {
+      client_name: "Garuda",
+      redirect_uris: [this.redirectUrl],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none"
+    };
+  }
+  state() {
+    this.expectedState = randomBytes(16).toString("hex");
+    return this.expectedState;
+  }
+  get stateValue() {
+    return this.expectedState;
+  }
+  clientInformation() {
+    return this.store.get(this.key).client;
+  }
+  async saveClientInformation(info) {
+    await this.store.update(this.key, { client: info, port: this.port });
+  }
+  tokens() {
+    return this.store.get(this.key).tokens;
+  }
+  async saveTokens(tokens) {
+    await this.store.update(this.key, { tokens });
+  }
+  redirectToAuthorization(url) {
+    this.authorizationUrl = url;
+  }
+  saveCodeVerifier(verifier) {
+    this.verifier = verifier;
+  }
+  /**
+   * The discovery result, kept with the other sign-in data. The SDK checks at the callback that the
+   * authorization server is still the one that it sent the user to (SEP-2352): a code and its PKCE
+   * verifier must never go to another server's token endpoint.
+   */
+  async saveDiscoveryState(state) {
+    await this.store.update(this.key, { discovery: state });
+  }
+  discoveryState() {
+    return this.store.get(this.key).discovery;
+  }
+  codeVerifier() {
+    if (this.verifier === void 0)
+      throw new Error("No PKCE code verifier: start the sign-in again.");
+    return this.verifier;
+  }
+  async invalidateCredentials(scope) {
+    if (scope === "verifier" || scope === "all") this.verifier = void 0;
+    if (scope === "discovery" || scope === "all") {
+      await this.store.update(this.key, { discovery: void 0 });
+    }
+    if (scope === "tokens" || scope === "all")
+      await this.store.update(this.key, { tokens: void 0 });
+    if (scope === "client" || scope === "all")
+      await this.store.update(this.key, { client: void 0 });
+  }
+};
+function freePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      server.close(
+        () => typeof address === "object" && address !== null ? resolve(address.port) : reject(new Error("no port"))
+      );
+    });
+  });
+}
+var CallbackError = class extends Error {
+};
+function waitForCallback(port, expectedState, signal) {
+  let server;
+  let settle;
+  const result = new Promise((resolve, reject) => {
+    settle = { resolve, reject };
+  });
+  const finish = (fn) => {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", onAbort);
+    server?.close();
+    fn();
+  };
+  const onAbort = () => finish(() => settle?.reject(signal.reason));
+  const timer = setTimeout(
+    () => finish(
+      () => settle?.reject(
+        new CallbackError(`No sign-in within ${SIGN_IN_TIMEOUT_MS / 6e4} minutes.`)
+      )
+    ),
+    SIGN_IN_TIMEOUT_MS
+  );
+  signal.addEventListener("abort", onAbort, { once: true });
+  const listening = new Promise((resolve, reject) => {
+    server = createServer((req, res) => {
+      const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404).end();
+        return;
+      }
+      const params = url.searchParams;
+      const ok = params.get("state") !== null && params.get("state") === expectedState();
+      res.writeHead(ok ? 200 : 400, { "content-type": "text/html; charset=utf-8" });
+      res.end(
+        ok && params.has("code") ? "<p>Signed in. You can close this tab and go back to Garuda.</p>" : "<p>The sign-in did not work. Go back to Garuda.</p>"
+      );
+      if (!ok) {
+        return;
+      }
+      if (!params.has("code")) {
+        const code = cleanText(params.get("error") ?? "no code").slice(0, 40);
+        finish(() => settle?.reject(new CallbackError(`The sign-in failed (${code}).`)));
+        return;
+      }
+      finish(() => settle?.resolve(params));
+    });
+    server.once("error", (error) => {
+      finish(() => settle?.reject(error));
+      reject(error);
+    });
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+  result.catch(() => {
+  });
+  return { listening, result };
+}
+
+export {
+  AUTH_FILE,
+  SIGN_IN_TIMEOUT_MS,
+  AuthStore,
+  authKey,
+  GarudaOAuthProvider,
+  freePort,
+  CallbackError,
+  waitForCallback
+};
+//# sourceMappingURL=chunk-3CEPHS4C.js.map

package/dist/chunk-3NJNVZTK.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+
+// src/permissions/rules.ts
+var RULE = /^([a-z_][a-z0-9_-]*\*?)(?:\((.*)\))?$/i;
+function parseRule(text) {
+  const match = RULE.exec(text.trim());
+  if (match === null || match[1] === void 0) {
+    throw new Error(`Invalid permission rule "${text}". Use "tool" or "tool(pattern)".`);
+  }
+  const pattern = match[2]?.trim();
+  return pattern === void 0 || pattern === "" ? { tool: match[1] } : { tool: match[1], pattern };
+}
+function formatRule(rule) {
+  return rule.pattern === void 0 ? rule.tool : `${rule.tool}(${rule.pattern})`;
+}
+function ruleMatches(rule, tool, target, mode) {
+  if (!toolMatches(rule.tool, tool)) return false;
+  if (rule.pattern === void 0) return true;
+  if (target === void 0) return false;
+  if (target.kind === "path") return pathMatches(rule.pattern, target.path);
+  if (target.kind === "input") return false;
+  if (target.kind === "url") return hostMatches(rule.pattern, target.host);
+  if (rule.exact) return normalize(target.command) === normalize(rule.pattern);
+  const parts = commandParts(target.command, mode === "deny");
+  if (parts.length === 0) return false;
+  const hit = (part) => commandMatches(rule.pattern ?? "", part);
+  return mode === "allow" ? parts.every(hit) : parts.some(hit) || hit(target.command);
+}
+function toolMatches(ruleTool, tool) {
+  return ruleTool.endsWith("*") ? tool.startsWith(ruleTool.slice(0, -1)) : ruleTool === tool;
+}
+function hostMatches(pattern, host) {
+  const p = pattern.toLowerCase();
+  const h = host.toLowerCase();
+  return p.startsWith("*.") ? h.endsWith(p.slice(1)) && h.length > p.length - 1 : p === h;
+}
+var CASE_INSENSITIVE_FS = process.platform === "darwin" || process.platform === "win32";
+function pathMatches(pattern, path, ignoreCase = CASE_INSENSITIVE_FS) {
+  return globToRegExp(fullGlob(pattern), ignoreCase).test(path);
+}
+function fullGlob(pattern) {
+  return pattern.includes("/") ? pattern.replace(/^\.?\//, "") : `**/${pattern}`;
+}
+function globToRegExp(glob, ignoreCase) {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i] ?? "";
+    if (glob.startsWith("**/", i)) {
+      out += "(?:.*/)?";
+      i += 2;
+    } else if (glob.startsWith("**", i)) {
+      out += ".*";
+      i += 1;
+    } else if (c === "*") out += "[^/]*";
+    else if (c === "?") out += "[^/]";
+    else out += escapeRegExp(c);
+  }
+  return new RegExp(`^${out}$`, ignoreCase ? "i" : "");
+}
+function commandMatches(pattern, command) {
+  const regex = normalize(pattern).split("*").map(escapeRegExp).join(".*");
+  return new RegExp(`^${regex}$`, "s").test(normalize(command));
+}
+function commandParts(command, stripPrefixesToo = true) {
+  const parts = [];
+  let current = "";
+  let quote;
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i] ?? "";
+    if (quote !== void 0) {
+      if (c === quote) quote = void 0;
+      else if (c === "\\" && quote === '"') {
+        current += c + (command[i + 1] ?? "");
+        i++;
+        continue;
+      }
+      current += c;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      quote = c;
+      current += c;
+    } else if (c === "\\") {
+      current += c + (command[i + 1] ?? "");
+      i++;
+    } else if (";&|\n`()".includes(c) || c === "$" && command[i + 1] === "(") {
+      parts.push(current);
+      current = "";
+    } else current += c;
+  }
+  parts.push(current);
+  return parts.map((part) => stripPrefixesToo ? stripPrefixes(part) : normalize(part)).filter((part) => part !== "");
+}
+function stripPrefixes(part) {
+  let words = normalize(part).replace(/^[{}!\s]+/, "").split(" ");
+  for (; ; ) {
+    const first = words[0] ?? "";
+    if (first === "sudo" || first === "env" || first === "exec" || first === "command") {
+      words = words.slice(1);
+    } else if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(first)) words = words.slice(1);
+    else break;
+  }
+  return words.join(" ").replace(/[{}\s]+$/, "");
+}
+function normalize(text) {
+  return text.trim().replace(/\s+/g, " ");
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+}
+
+export {
+  parseRule,
+  formatRule,
+  ruleMatches,
+  hostMatches,
+  CASE_INSENSITIVE_FS,
+  pathMatches,
+  fullGlob,
+  commandMatches,
+  commandParts
+};
+//# sourceMappingURL=chunk-3NJNVZTK.js.map

package/dist/chunk-42DSA4EA.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+// src/init/detect.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { extname, join } from "path";
+var MARKERS = [
+  "package.json",
+  "pom.xml",
+  "build.gradle",
+  "build.gradle.kts",
+  "pyproject.toml",
+  "setup.py",
+  "requirements.txt",
+  "Cargo.toml",
+  "go.mod",
+  "Gemfile",
+  "composer.json",
+  "CMakeLists.txt",
+  "Makefile",
+  "deno.json"
+];
+var CODE = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".java",
+  ".kt",
+  ".go",
+  ".rs",
+  ".rb",
+  ".php",
+  ".cs",
+  ".c",
+  ".h",
+  ".cpp",
+  ".hpp",
+  ".swift",
+  ".scala",
+  ".sh",
+  ".sql",
+  ".vue",
+  ".svelte",
+  ".dart"
+]);
+var SKIP = /* @__PURE__ */ new Set(["node_modules", "target", "build", "dist", "venv", "__pycache__"]);
+var MAX_ENTRIES = 5e3;
+function folderKind(root) {
+  if (MARKERS.some((m) => existsSync(join(root, m)))) return "code";
+  let seen = 0;
+  let files = 0;
+  const walk = (dir, depth) => {
+    let names;
+    try {
+      names = readdirSync(dir);
+    } catch {
+      return false;
+    }
+    for (const name of names) {
+      if (++seen > MAX_ENTRIES) return false;
+      if (name.startsWith(".") || SKIP.has(name)) continue;
+      const full = join(dir, name);
+      let isDir = false;
+      try {
+        isDir = statSync(full).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDir) {
+        if (depth < 3 && walk(full, depth + 1)) return true;
+        continue;
+      }
+      files++;
+      if (CODE.has(extname(name).toLowerCase())) return true;
+    }
+    return false;
+  };
+  if (walk(root, 1)) return "code";
+  return files === 0 ? "empty" : "notes";
+}
+var OTHER_AGENTS = [
+  [".claude", "Claude Code"],
+  [".mcp.json", "Claude Code"],
+  ["opencode.json", "OpenCode"],
+  [".opencode", "OpenCode"],
+  [".codex", "Codex"],
+  [".gemini", "Gemini CLI"],
+  ["GEMINI.md", "Gemini CLI"],
+  [".tabnine", "Tabnine"],
+  ["TABNINE.md", "Tabnine"],
+  [".cursor", "Cursor"],
+  [".cursorrules", "Cursor"],
+  [".github/copilot-instructions.md", "Copilot"]
+];
+function initTip(root) {
+  const others = [
+    ...new Set(OTHER_AGENTS.filter(([p]) => existsSync(join(root, p))).map(([, a]) => a))
+  ];
+  const hasInstructions = ["AGENTS.md", "CLAUDE.md", "GARUDA.md"].some(
+    (f) => existsSync(join(root, f))
+  );
+  if (others.length > 0 && !existsSync(join(root, ".garuda"))) {
+    return `Found files of ${others.join(", ")}. Type /init to bring their commands, MCP servers and rules over.`;
+  }
+  if (hasInstructions) return void 0;
+  return folderKind(root) === "code" ? "Type /init to write AGENTS.md: build commands, structure and conventions for the agent." : "This folder has no code yet. Type /init to start a project here.";
+}
+
+export {
+  folderKind,
+  initTip
+};
+//# sourceMappingURL=chunk-42DSA4EA.js.map

package/dist/chunk-4JSUUDFQ.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+// src/cli/approver.ts
+import { styleText } from "util";
+var TerminalApprover = class {
+  /** Set by the CLI: it aborts the current turn. */
+  onInterrupt = () => {
+  };
+  /** One question at a time (0.14.1, review): two prompts at once mixed their keys. */
+  ask(request, signal) {
+    const next = this.asking === 0 ? this.askNow(request, signal) : this.queue.then(() => this.askNow(request, signal));
+    this.asking++;
+    this.queue = next.catch(() => {
+    }).finally(() => {
+      this.asking--;
+    });
+    return next;
+  }
+  asking = 0;
+  queue = Promise.resolve();
+  async askNow(request, signal) {
+    signal.throwIfAborted();
+    const out = process.stderr;
+    out.write(`
+${header(request)}
+${colorPreview(request)}
+`);
+    if (!process.stdin.isTTY) {
+      out.write("No terminal to ask for approval, so Garuda denies this call.\n");
+      return "deny";
+    }
+    const sessionLabel = request.labels?.session ?? (request.target.kind === "command" ? "Yes, and allow this exact command for this session" : request.target.kind === "url" ? `Yes, and allow ${request.target.host} for this session` : `Yes, and allow all ${request.tool} calls for this session`);
+    const { select } = await import("@inquirer/prompts");
+    try {
+      return await select(
+        {
+          message: request.question ?? "Allow?",
+          choices: [
+            { name: request.labels?.once ?? "Yes, once", value: "once" },
+            { name: sessionLabel, value: "session" },
+            { name: request.labels?.deny ?? "No, deny", value: "deny" }
+          ].filter((c) => request.choices?.includes(c.value) ?? true)
+        },
+        { signal, output: out }
+      );
+    } catch (error) {
+      if (error.name === "ExitPromptError") this.onInterrupt();
+      throw error;
+    }
+  }
+};
+var SwitchApprover = class {
+  constructor(current) {
+    this.current = current;
+  }
+  current;
+  /** Called before each question: the chat's notifier (0.6). */
+  onAsk = () => {
+  };
+  ask(request, signal) {
+    this.onAsk(request);
+    return this.current.ask(request, signal);
+  }
+};
+function visible(text) {
+  return text.replace(/[\u0000-\u0008\u000b-\u001f]/g, (c) => String.fromCodePoint(9216 + c.charCodeAt(0))).replace(/\u007f/g, "\u2421").replace(
+    /[\u0080-\u009f\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff\u{e0000}-\u{e007f}]/gu,
+    (c) => `[U+${(c.codePointAt(0) ?? 0).toString(16).toUpperCase().padStart(4, "0")}]`
+  );
+}
+function hasHidden(text) {
+  return visible(text) !== text;
+}
+var HIDDEN_WARNING = "! This holds hidden or control characters, shown as \u240D, \u241B or [U+\u2026]. Read it with care.";
+function headerText(request) {
+  const { tool, target, isolation } = request;
+  if (request.title !== void 0) return visible(request.title);
+  if (target.kind === "command") {
+    const where = isolation === "none" ? "on your machine, no sandbox" : target.outsideSandbox ? "OUTSIDE the sandbox: network on, writes anywhere" : `sandbox: ${isolation}`;
+    return `${tool} wants to run a command (${where}):`;
+  }
+  if (target.kind === "input") return `${tool} wants to run with this input:`;
+  if (target.kind === "url") return `${tool} wants to fetch from ${visible(target.host)}:`;
+  return `${tool} wants to change ${visible(target.path)}:`;
+}
+function header(request) {
+  return styleText("bold", headerText(request));
+}
+function colorPreview({ target, preview }) {
+  const warning = hasHidden(preview) ? `
+${styleText("yellow", `  ${HIDDEN_WARNING}`)}` : "";
+  if (target.kind === "command") return `${styleText("cyan", `  $ ${visible(preview)}`)}${warning}`;
+  if (target.kind === "url") return `${visible(preview)}${warning}`;
+  return `${colorDiff(visible(preview))}${warning}`;
+}
+function colorDiff(text) {
+  return text.split("\n").map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("diff --git"))
+      return styleText("bold", line);
+    if (line.startsWith("+")) return styleText("green", line);
+    if (line.startsWith("-")) return styleText("red", line);
+    if (line.startsWith("@@")) return styleText("cyan", line);
+    return line;
+  }).join("\n");
+}
+
+export {
+  TerminalApprover,
+  SwitchApprover,
+  visible,
+  hasHidden,
+  HIDDEN_WARNING,
+  headerText,
+  header,
+  colorPreview,
+  colorDiff
+};
+//# sourceMappingURL=chunk-4JSUUDFQ.js.map

package/dist/chunk-4P26OKTP.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import {
+  checkAddress,
+  isIpLiteral
+} from "./chunk-ATW7BNIG.js";
+
+// src/net/pinnedFetch.ts
+import { lookup as dnsLookup } from "dns/promises";
+import { request as httpRequest } from "http";
+import { request as httpsRequest } from "https";
+import { Readable } from "stream";
+var BlockedAddressError = class extends Error {
+};
+var defaultResolve = (host) => dnsLookup(host, { all: true, verbatim: true });
+function pinnedFetch(options = {}) {
+  const resolve = options.resolve ?? defaultResolve;
+  return (async (input, init = {}) => {
+    const url = new URL(input instanceof Request ? input.url : input.toString());
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      throw new BlockedAddressError(`Only http and https, not ${url.protocol}`);
+    }
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    const addresses = isIpLiteral(host) ? [{ address: host, family: host.includes(":") ? 6 : 4 }] : await resolve(host);
+    if (addresses.length === 0) throw new BlockedAddressError(`${host} has no address.`);
+    for (const a of addresses) {
+      const verdict = checkAddress(a.address, false);
+      if (!verdict.ok) {
+        throw new BlockedAddressError(
+          `${host} resolves to a ${verdict.range} address (${a.address}). A project's MCP server must be public.`
+        );
+      }
+    }
+    const pinned = addresses[0];
+    const lookup = (_host, opts, callback) => {
+      if (opts.all) callback(null, [pinned]);
+      else callback(null, pinned.address, pinned.family);
+    };
+    const headers = new Headers(
+      init.headers ?? (input instanceof Request ? input.headers : void 0)
+    );
+    const body = await bodyBytes(
+      init.body ?? (input instanceof Request ? await input.arrayBuffer() : void 0)
+    );
+    if (init.body instanceof URLSearchParams && !headers.has("content-type")) {
+      headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8");
+    }
+    if (body !== void 0) headers.set("content-length", String(body.byteLength));
+    const method = init.method ?? (input instanceof Request ? input.method : "GET");
+    const signal = init.signal ?? void 0;
+    const request = url.protocol === "https:" ? httpsRequest : httpRequest;
+    return new Promise((resolvePromise, reject) => {
+      const req = request(
+        url,
+        {
+          method,
+          headers: Object.fromEntries(headers.entries()),
+          lookup,
+          ...url.protocol === "https:" ? { servername: isIpLiteral(host) ? void 0 : host } : {},
+          ...signal === void 0 || signal === null ? {} : { signal }
+        },
+        (res) => {
+          const status = res.statusCode ?? 0;
+          const responseHeaders = new Headers();
+          for (const [key, value] of Object.entries(res.headers)) {
+            if (value === void 0) continue;
+            for (const v of Array.isArray(value) ? value : [value]) responseHeaders.append(key, v);
+          }
+          const empty = status === 204 || status === 304 || method === "HEAD";
+          if (empty) res.resume();
+          resolvePromise(
+            new Response(empty ? null : Readable.toWeb(res), {
+              status,
+              statusText: res.statusMessage ?? "",
+              headers: responseHeaders
+            })
+          );
+        }
+      );
+      req.on("error", reject);
+      if (body !== void 0) req.write(body);
+      req.end();
+    });
+  });
+}
+async function bodyBytes(body) {
+  if (body === void 0 || body === null) return void 0;
+  if (typeof body === "string") return new TextEncoder().encode(body);
+  if (body instanceof Uint8Array) return body;
+  if (body instanceof ArrayBuffer) return new Uint8Array(body);
+  if (body instanceof URLSearchParams) return new TextEncoder().encode(body.toString());
+  return new Uint8Array(
+    await new Response(body).arrayBuffer()
+  );
+}
+
+export {
+  defaultResolve,
+  pinnedFetch
+};
+//# sourceMappingURL=chunk-4P26OKTP.js.map