@oirnoir/util 0.0.60 → 0.0.62

package/dist/Proxy.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The response object for the request. Includes the
+ * response headers from the proxy service.
+ */
+export interface ProxyResponse extends Response {
+    proxyHeaders: Headers;
+}
+/**
+ * Proxy requests through a specific proprietary proxy.
+ */
+export declare class FetchProxy {
+    proxyEndpoint: string;
+    constructor(proxyEndpoint: string);
+    fetch(endpoint: string | URL, options?: RequestInit): Promise<ProxyResponse>;
+}
+//# sourceMappingURL=Proxy.d.ts.map

package/dist/Proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Proxy.d.ts","sourceRoot":"","sources":["../src/Proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAc,SAAQ,QAAQ;IAC9C,YAAY,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,UAAU;IACtB,aAAa,EAAE,MAAM,CAAC;gBAEV,aAAa,EAAE,MAAM;IAM3B,KAAK,CACV,QAAQ,EAAE,MAAM,GAAG,GAAG,EACtB,OAAO,GAAE,WAAgB,GACvB,OAAO,CAAC,aAAa,CAAC;CA2CzB"}

package/dist/Type.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The class for deep checking Types
+ */
+export declare class Type {
+    /**
+     * The value to generate a deep Type of
+     */ value: any;
+    /**
+     * The shallow type of this
+     */
+    is: string;
+    /**
+     * The parent of this type
+     */
+    private parent?;
+    /**
+     * The child keys of this Type
+     */
+    private childKeys;
+    /**
+     * The child values of this Type
+     */
+    private childValues;
+    /**
+     * @param value - The value to generate a deep Type of
+     * @param parent - The parent value used in recursion
+     */ constructor(value: any, parent?: Type);
+    /**
+     * The type string for the children of this Type
+     */
+    get childTypes(): string;
+    /**
+     * The full type string generated.
+     */
+    toString(): string;
+    /**
+     * The subtype to create based on this.value's sub value.
+     */ addValue(value: any): void;
+    /**
+     * The subtype to create based on this.value's entries.
+     */ private addEntry;
+    /**
+     * Walks the linked list backwards, for checking circulars.
+     */
+    private parents;
+    /**
+     * Get the deep type name that defines the input.
+     */
+    check(): void;
+    /**
+     * Checks if the value of this Type is a circular reference to any parent.
+     */
+    isCircular(): boolean;
+    /**
+     * Resolves the type name that defines the input.
+     */
+    static resolve(value: any): string;
+    /**
+     * Joins the list of child types.
+     */
+    static list(values: Map<string, Type>): string;
+}
+//# sourceMappingURL=Type.d.ts.map

package/dist/Type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Type.d.ts","sourceRoot":"","sources":["../src/Type.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,IAAI;IAChB;;OAEG,CACI,KAAK,EAAE,GAAG,CAAC;IAElB;;OAEG;IACI,EAAE,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,CAAO;IAEtB;;OAEG;IACH,OAAO,CAAC,SAAS,CAAoB;IAErC;;OAEG;IACH,OAAO,CAAC,WAAW,CAAoB;IAEvC;;;OAGG,aACS,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,IAAI;IAQrC;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAMvB;IAED;;OAEG;IACH,QAAQ,IAAI,MAAM;IAKlB;;OAEG,CACI,QAAQ,CAAC,KAAK,EAAE,GAAG;IAK1B;;OAEG,CACH,OAAO,CAAC,QAAQ;IAMhB;;OAEG;IACH,OAAO,CAAE,OAAO;IAMhB;;OAEG;IACH,KAAK;IAYL;;OAEG;IACH,UAAU,IAAI,OAAO;IAMrB;;OAEG;IAEH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM;IAclC;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,MAAM;CAG9C"}

package/dist/index.d.ts

@@ -0,0 +1,78 @@
+import { type ExecException, type ExecOptions } from "node:child_process";
+export * from "./Proxy.ts";
+export * from "./Type.ts";
+/**
+ * Adds commas to a number, for pretty human reading
+ */
+export declare function commaNumber(num: number): string;
+/**
+ * Represents a parsed user-inputted time.
+ * Returned by parseUserInputtedTime.
+ */
+export declare class ParsedTime {
+    readonly intervalMs: number;
+    readonly timestamp?: number;
+    constructor(data: {
+        intervalMs: number;
+        timestamp?: number;
+    });
+    get intervalSeconds(): number;
+    get string(): string;
+}
+/**
+ * Parse user-inputted time. Timestamps can be allowed, optionally.
+ * relativeTime is used to calculate intervals when timestamps are
+ * inputted.
+ */
+export declare function parseUserInputtedTime(rawTimeInterval: string, allowTimestamps?: boolean, relativeTime?: number): ParsedTime;
+/**
+ * Converts a quantity of ms to human-readable format
+ */
+export declare function msToHuman(ms: number, includeMilliseconds?: boolean): string;
+/**
+ * Converts a quantity of ms to a shorter human-readable format
+ */
+export declare function msToShort(ms: number, includeMilliseconds?: boolean): string;
+/**
+ * Generate a random string of a specific length. Uses Math.random().
+ */
+export declare function randomString(length: number, alphabet?: string): string;
+/**
+ * Check if a string is entirely numeric.
+ */
+export declare function isNumeric(str: string | undefined | null, options: {
+    allowNegative: boolean;
+    allowDecimal: boolean;
+}): boolean;
+/**
+ * Returns a promise that resolves after a given number of milliseconds.
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Asynchronously execute a command-line command.
+ */
+export declare function execAsync(command: string, settings?: ExecOptions): Promise<{
+    error: ExecException | null;
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * A lightweight curl wrapper. Input arguments
+ * for curl, and a web API Response object is returned.
+ */
+export declare function curl(...curlArgs: string[]): Promise<Response>;
+/**
+ * Parses a raw HTTP response into a fetch Response
+ */
+export declare function parseRawHttpResponse(raw: string): Response;
+/**
+ * Await a promise, but reject if the promise takes too long.
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeout: number): Promise<T>;
+/**
+ * Similar to `Array#splice()` but for two Uint8Arrays.
+ * Replaces `deleteCount` bytes of `array` starting from `start`
+ * with the contents of `toInsert`. If `toInsert` is not given, just deletes `deleteCount`.
+ */
+export declare function spliceUint8Array(array: Uint8Array, start: number, deleteCount: number, toInsert?: Uint8Array): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,aAAa,EAClB,KAAK,WAAW,EAGhB,MAAM,oBAAoB,CAAC;AAK5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAE1B;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI/C;AAED;;;GAGG;AACH,qBAAa,UAAU;IACtB,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,SAAS,CAAC,EAAE,MAAM,CAAC;gBAEvB,IAAI,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;IAK5D,IAAI,eAAe,IAAI,MAAM,CAE5B;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;CACD;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACpC,eAAe,EAAE,MAAM,EACvB,eAAe,UAAQ,EACvB,YAAY,GAAE,MAAmB,GAC/B,UAAU,CAmCZ;AAiBD;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,mBAAmB,UAAQ,GAAG,MAAM,CAoCzE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,mBAAmB,UAAQ,GAAG,MAAM,CA0CzE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC3B,MAAM,EAAE,MAAM,EACd,QAAQ,SAAmE,GACzE,MAAM,CAQR;AAED;;GAEG;AACH,wBAAgB,SAAS,CACxB,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,EAC9B,OAAO,EAAE;IAAE,aAAa,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,GACxD,OAAO,CAiBT;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAI/C;AAED;;GAEG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,WAAW,GACpB,OAAO,CAAC;IACV,KAAK,EAAE,aAAa,GAAG,IAAI,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CACf,CAAC,CAMD;AAED;;;GAGG;AACH,wBAAsB,IAAI,CAAC,GAAG,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,QAAQ,CAAC,CAwBnE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,CA6B1D;AAID;;GAEG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAClC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,OAAO,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,CAAC,CAUZ;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,UAAU,GACnB,UAAU,CAAC,WAAW,CAAC,CAazB"}

package/dist/index.js

@@ -0,0 +1,425 @@
+// src/index.ts
+import {
+  exec,
+  spawn
+} from "node:child_process";
+import { setTimeout } from "node:timers";
+import timeString from "timestring";
+
+// src/Proxy.ts
+var FetchProxy = class {
+  proxyEndpoint;
+  constructor(proxyEndpoint) {
+    this.proxyEndpoint = proxyEndpoint;
+    if (this.proxyEndpoint.length == 0)
+      throw new Error("Proxy endpoint must not be a blank string");
+  }
+  async fetch(endpoint, options = {}) {
+    const configuredOptions = {
+      method: options.method ?? "GET",
+      body: options.body ?? void 0,
+      mode: options.mode ?? void 0,
+      keepalive: options.keepalive ?? void 0,
+      signal: options.signal ?? void 0,
+      credentials: options.credentials ?? void 0,
+      redirect: "manual",
+      headers: {
+        endpoint: typeof endpoint == "string" ? endpoint : endpoint.toString(),
+        /* cspell: disable-next-line */
+        "oproxy-options": JSON.stringify({
+          method: options.method ?? "GET",
+          mode: options.mode ?? void 0,
+          credentials: options.credentials ?? void 0,
+          redirect: options.redirect ?? void 0,
+          referrer: options.referrer ?? void 0,
+          referrerPolicy: options.referrerPolicy ?? void 0,
+          integrity: options.integrity ?? void 0,
+          keepalive: options.keepalive ?? void 0
+        }),
+        headers: options.headers == null ? "{}" : JSON.stringify(options.headers)
+      }
+    };
+    const res = await fetch(this.proxyEndpoint, configuredOptions);
+    const receivedHeaders = res.headers.has("incomingHeaders") ? JSON.parse(res.headers?.get("incomingHeaders") ?? "") : null;
+    const receivedStatus = res.headers.has("receivedStatus") ? Number(res.headers.get("receivedStatus")) : res.status;
+    Object.defineProperty(res, "status", { get: () => receivedStatus });
+    const proxyHeaders = res.headers;
+    Object.defineProperty(res, "proxyHeaders", { get: () => proxyHeaders });
+    const resWithHeaders = res;
+    if (receivedHeaders != null) {
+      Object.defineProperty(resWithHeaders, "headers", {
+        get: () => new Headers(receivedHeaders)
+      });
+    }
+    return resWithHeaders;
+  }
+};
+
+// src/Type.ts
+var Type = class _Type {
+  /**
+   * The value to generate a deep Type of
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: This can truly be any
+  value;
+  /**
+   * The shallow type of this
+   */
+  is;
+  /**
+   * The parent of this type
+   */
+  parent;
+  /**
+   * The child keys of this Type
+   */
+  childKeys;
+  /**
+   * The child values of this Type
+   */
+  childValues;
+  /**
+   * @param value - The value to generate a deep Type of
+   * @param parent - The parent value used in recursion
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: This can truly be any
+  constructor(value, parent) {
+    this.value = value;
+    this.is = _Type.resolve(value);
+    this.parent = parent;
+    this.childKeys = /* @__PURE__ */ new Map();
+    this.childValues = /* @__PURE__ */ new Map();
+  }
+  /**
+   * The type string for the children of this Type
+   */
+  get childTypes() {
+    if (!this.childValues.size) return "";
+    return `<${(this.childKeys.size ? `${_Type.list(this.childKeys)}, ` : "") + _Type.list(this.childValues)}>`;
+  }
+  /**
+   * The full type string generated.
+   */
+  toString() {
+    this.check();
+    return this.is + this.childTypes;
+  }
+  /**
+   * The subtype to create based on this.value's sub value.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: This can truly be any
+  addValue(value) {
+    const child = new _Type(value, this);
+    this.childValues.set(child.is, child);
+  }
+  /**
+   * The subtype to create based on this.value's entries.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: This can truly be any
+  addEntry([key, value]) {
+    const child = new _Type(key, this);
+    this.childKeys.set(child.is, child);
+    this.addValue(value);
+  }
+  /**
+   * Walks the linked list backwards, for checking circulars.
+   */
+  *parents() {
+    let current = this;
+    while (current = current.parent) yield current;
+  }
+  /**
+   * Get the deep type name that defines the input.
+   */
+  check() {
+    if (Object.isFrozen(this)) return;
+    if (typeof this.value === "object" && this.isCircular())
+      this.is = `[Circular:${this.is}]`;
+    else if (this.value instanceof Map)
+      for (const entry of this.value) this.addEntry(entry);
+    else if (Array.isArray(this.value) || this.value instanceof Set)
+      for (const value of this.value) this.addValue(value);
+    else if (this.is === "Object") this.is = "any";
+    Object.freeze(this);
+  }
+  /**
+   * Checks if the value of this Type is a circular reference to any parent.
+   */
+  isCircular() {
+    for (const parent of this.parents())
+      if (parent.value === this.value) return true;
+    return false;
+  }
+  /**
+   * Resolves the type name that defines the input.
+   */
+  // biome-ignore lint/suspicious/noExplicitAny: This can truly be any
+  static resolve(value) {
+    const type = typeof value;
+    switch (type) {
+      case "object":
+        return value === null ? "null" : value.constructor?.name || "any";
+      case "function":
+        return `${value.constructor.name}(${value.length}-arity)`;
+      case "undefined":
+        return "void";
+      default:
+        return type;
+    }
+  }
+  /**
+   * Joins the list of child types.
+   */
+  static list(values) {
+    return values.has("any") ? "any" : [...values.values()].sort().join(" | ");
+  }
+};
+
+// src/index.ts
+function commaNumber(num) {
+  return num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+var ParsedTime = class {
+  intervalMs;
+  timestamp;
+  constructor(data) {
+    this.intervalMs = data.intervalMs;
+    this.timestamp = data.timestamp;
+  }
+  get intervalSeconds() {
+    return Math.trunc(this.intervalMs / 1e3);
+  }
+  get string() {
+    return msToHuman(this.intervalMs);
+  }
+};
+function parseUserInputtedTime(rawTimeInterval, allowTimestamps = false, relativeTime = Date.now()) {
+  const digits = rawTimeInterval.match(/\d/g);
+  if ((rawTimeInterval.endsWith("t") || digits != null && digits.length > 0 && digits.join("") == rawTimeInterval) && allowTimestamps) {
+    let timestampString = rawTimeInterval.match(/\d/g)?.join("");
+    if (timestampString == null || !isNumeric(timestampString, { allowDecimal: true, allowNegative: true }))
+      timestampString = String(relativeTime);
+    const timestamp = timestampString.length == String(relativeTime).length || timestampString.length == String(relativeTime).length + 1 || timestampString.length == String(relativeTime).length - 1 ? Number(timestampString) : timestampString.length == String(relativeTime).length - 3 || timestampString.length == String(relativeTime).length - 2 || timestampString.length == String(relativeTime).length - 4 ? Number(timestampString) * 1e3 : Number(timestampString);
+    const timeInterval2 = timestamp - relativeTime;
+    return new ParsedTime({ intervalMs: timeInterval2, timestamp });
+  }
+  let timeInterval;
+  try {
+    timeInterval = timeString(rawTimeInterval, "ms");
+  } catch {
+    return { intervalSeconds: 0, intervalMs: 0, string: "" };
+  }
+  return new ParsedTime({ intervalMs: timeInterval });
+}
+function explodeMs(ms) {
+  return {
+    milliseconds: Math.trunc(ms % 1e3),
+    seconds: Math.trunc(ms / 1e3 % 60),
+    minutes: Math.trunc(ms / 6e4 % 60),
+    hours: Math.trunc(ms / 36e5 % 24),
+    days: Math.trunc(ms / 864e5 % 7),
+    weeks: Math.trunc(ms / 6048e5 % 52),
+    years: Math.trunc(ms / 314496e5)
+  };
+}
+function msToHuman(ms, includeMilliseconds = false) {
+  const { milliseconds, seconds, minutes, hours, days, weeks, years } = explodeMs(ms);
+  const durationComponents = [];
+  if (years > 0) {
+    durationComponents.push(`${years} year${years == 1 ? "" : "s"}`);
+  }
+  if (weeks > 0) {
+    durationComponents.push(`${weeks} week${weeks == 1 ? "" : "s"}`);
+  }
+  if (days > 0) {
+    durationComponents.push(`${days} day${days == 1 ? "" : "s"}`);
+  }
+  if (hours > 0) {
+    durationComponents.push(`${hours} hour${hours == 1 ? "" : "s"}`);
+  }
+  if (minutes > 0) {
+    durationComponents.push(`${minutes} minute${minutes == 1 ? "" : "s"}`);
+  }
+  if (seconds > 0) {
+    durationComponents.push(`${seconds} second${seconds == 1 ? "" : "s"}`);
+  }
+  if (milliseconds > 0 && includeMilliseconds) {
+    durationComponents.push(
+      `${milliseconds} millisecond${milliseconds == 1 ? "" : "s"}`
+    );
+  }
+  if (durationComponents.length == 0)
+    durationComponents.push(
+      includeMilliseconds ? "no time" : "less than a second"
+    );
+  const durationWords = durationComponents.length >= 3 ? `${durationComponents.slice(0, -1).join(", ")}, and ${durationComponents.at(-1)}` : durationComponents.join(" and ");
+  return durationWords;
+}
+function msToShort(ms, includeMilliseconds = false) {
+  const { milliseconds, seconds, minutes, hours, days, weeks, years } = explodeMs(ms);
+  let twoDigitMin = String(minutes);
+  while (twoDigitMin.length < 2) {
+    twoDigitMin = `0${twoDigitMin}`;
+  }
+  let twoDigitSec = String(seconds);
+  while (twoDigitSec.length < 2) {
+    twoDigitSec = `0${twoDigitSec}`;
+  }
+  let threeDigitMs = String(milliseconds);
+  while (threeDigitMs.length < 3) {
+    threeDigitMs = `0${threeDigitMs}`;
+  }
+  const durationComponents = [];
+  let topFound = false;
+  if (years > 0 || topFound) {
+    topFound = true;
+    durationComponents.push(`${years}y`);
+  }
+  if (weeks > 0 || topFound) {
+    topFound = true;
+    durationComponents.push(`${weeks}w`);
+  }
+  if (days > 0 || topFound) {
+    topFound = true;
+    durationComponents.push(`${days}d `);
+  }
+  if (hours > 0 || topFound) {
+    topFound = true;
+    durationComponents.push(`${hours}:`);
+  }
+  if (minutes > 0 || topFound) {
+    durationComponents.push(`${topFound ? twoDigitMin : minutes}:${twoDigitSec}`);
+    if (includeMilliseconds) durationComponents.push(`.${threeDigitMs}`);
+  } else {
+    durationComponents.push(`${seconds}`);
+    if (includeMilliseconds) durationComponents.push(`.${threeDigitMs}`);
+    durationComponents.push("s");
+  }
+  return durationComponents.join("");
+}
+function randomString(length, alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789") {
+  let result = "";
+  let counter = 0;
+  while (counter < length) {
+    result += alphabet.charAt(Math.floor(Math.random() * alphabet.length));
+    counter += 1;
+  }
+  return result;
+}
+function isNumeric(str, options) {
+  if (str == null) return false;
+  let regex;
+  if (options.allowNegative) {
+    if (options.allowDecimal) {
+      regex = /^-?\d+(\.\d+)?$/;
+    } else {
+      regex = /^-?\d+$/;
+    }
+  } else {
+    if (options.allowDecimal) {
+      regex = /^\d+(\.\d+)?$/;
+    } else {
+      regex = /^\d+$/;
+    }
+  }
+  return regex.test(str);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function execAsync(command, settings) {
+  return new Promise((resolve) => {
+    exec(command, settings, (error, stdout, stderr) => {
+      resolve({ error, stdout, stderr });
+    });
+  });
+}
+async function curl(...curlArgs) {
+  const child = spawn("curl", ["-isSL", ...curlArgs]);
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+  child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+  const code = await new Promise((resolve, reject) => {
+    child.on("close", (c) => resolve(c ?? -1));
+    child.on("error", reject);
+  });
+  const stdoutText = new TextDecoder().decode(Buffer.concat(stdoutChunks));
+  const stderrText = new TextDecoder().decode(Buffer.concat(stderrChunks));
+  if (code !== 0) {
+    console.error("Curl stderr:");
+    console.error(stderrText);
+    throw new Error(`Curl exited with code ${code}`);
+  }
+  return parseRawHttpResponse(stdoutText);
+}
+function parseRawHttpResponse(raw) {
+  const [headerPart, ...bodyParts] = raw.split(/\r?\n\r?\n/);
+  const body = bodyParts.join("\n\n");
+  const lines = headerPart.split(/\r?\n/);
+  const statusLine = lines.shift();
+  if (statusLine === void 0)
+    throw new Error("Curl HTTP Response Syntax Error: No status line!");
+  const [, statusCode, ...statusTextParts] = statusLine.split(" ");
+  const status = Number(statusCode);
+  const statusText = statusTextParts.join(" ");
+  const headers = new Headers();
+  for (const line of lines) {
+    const idx = line.indexOf(":");
+    if (idx !== -1) {
+      headers.append(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+    }
+  }
+  const isNullBodyStatus = status === 101 || status === 204 || status === 205 || status === 304;
+  return new Response(isNullBodyStatus ? null : body, {
+    status,
+    statusText,
+    headers
+  });
+}
+var PrivateTimeoutIndicator = class {
+};
+async function withTimeout(promise, timeout) {
+  const promises = [
+    promise,
+    sleep(timeout).then(() => new PrivateTimeoutIndicator())
+  ];
+  const result = await Promise.race(promises);
+  if (result instanceof PrivateTimeoutIndicator) {
+    throw new Error("Timeout reached when awaiting promise resolution!");
+  }
+  return result;
+}
+function spliceUint8Array(array, start, deleteCount, toInsert) {
+  const s = Math.max(0, Math.min(Math.trunc(start) || 0, array.length));
+  const dc = Math.max(
+    0,
+    Math.min(Math.trunc(deleteCount) || 0, array.length - s)
+  );
+  const output = new Uint8Array(array.length - dc + (toInsert?.length ?? 0));
+  const before = array.slice(0, s);
+  const after = array.slice(s + dc, array.length);
+  output.set(before);
+  if (toInsert != void 0) output.set(toInsert, s);
+  output.set(after, s + (toInsert?.length ?? 0));
+  return output;
+}
+export {
+  FetchProxy,
+  ParsedTime,
+  Type,
+  commaNumber,
+  curl,
+  execAsync,
+  isNumeric,
+  msToHuman,
+  msToShort,
+  parseRawHttpResponse,
+  parseUserInputtedTime,
+  randomString,
+  sleep,
+  spliceUint8Array,
+  withTimeout
+};

package/package.json

@@ -1,45 +1,44 @@
 {
-	"name": "@oirnoir/util",
-	"version": "0.0.60",
-	"license": "MIT",
-	"description": "Utility methods for Node.js and Deno",
-	"type": "module",
-	"engines": {
-		"node": ">=26"
-	},
-	"exports": {
-		".": {
-			"deno": "./src/index.ts",
-			"types": "./dist/index.d.ts",
-			"import": "./dist/index.js"
-		}
-	},
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"files": [
-		"dist",
-		"src"
-	],
-	"scripts": {
-		"build": "esbuild src/index.ts --bundle --outfile=dist/index.js --format=esm --platform=node --external:timestring && tsc -p tsconfig.json",
-		"typecheck": "tsc --noEmit -p tsconfig.json",
-		"lint": "biome check . --write && biome lint",
-		"test": "node --test test/*.ts",
-		"publish:npm": "pnpm publish",
-		"publish:jsr": "deno publish --token $JSR_TOKEN"
-	},
-	"dependencies": {
-		"timestring": "^7.0.0"
-	},
-	"devDependencies": {
-		"@biomejs/biome": "2.6.2",
-		"@types/node": "26.6.6",
-		"@types/timestring": "^7.0.0",
-		"esbuild": "0.25.12",
-		"typescript": "5.9.3"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
-	"packageManager": "pnpm@12.16.1"
-}
+  "name": "@oirnoir/util",
+  "version": "0.0.62",
+  "license": "MIT",
+  "description": "Utility methods for Node.js and Deno",
+  "type": "module",
+  "engines": {
+    "node": ">=26"
+  },
+  "exports": {
+    ".": {
+      "deno": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "timestring": "^7.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.6.2",
+    "@types/node": "26.6.6",
+    "@types/timestring": "^7.0.0",
+    "esbuild": "0.25.12",
+    "typescript": "5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --outfile=dist/index.js --format=esm --platform=node --external:timestring && tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "lint": "biome check . --write && biome lint",
+    "test": "pnpm run build && node --test test/*.ts",
+    "publish:npm": "pnpm publish",
+    "publish:jsr": "deno publish --token $JSR_TOKEN"
+  }
+}