langsmith 0.5.23 → 0.5.25

package/dist/utils/serialize_worker.js

@@ -0,0 +1,383 @@
+/**
+ * Off-thread serialization using Node worker_threads.
+ *
+ * Gated behind LANGSMITH_PERF_OPTIMIZATION=true. Falls back silently to
+ * synchronous serialize() when:
+ *   - worker_threads is unavailable (browsers, Deno, Bun without compat,
+ *     Cloudflare Workers, Vercel Edge, React Native)
+ *   - the worker cannot be constructed (bundler/runtime constraints)
+ *   - DataCloneError is thrown for a payload containing non-cloneable
+ *     values (functions, class instances with non-cloneable state, etc.)
+ *   - the worker crashes or throws
+ *
+ * Protocol:
+ *   main -> worker: { id, op, payload }
+ *     op = "serialize" -> worker returns bytes as a transferable ArrayBuffer
+ *   worker -> main: { id, bytes?: ArrayBuffer, error?: string }
+ *
+ * The worker source is inlined as a string so the library bundles cleanly
+ * under webpack/esbuild/ncc without requiring a separate asset file.
+ */
+import { Worker as WorkerCtor, WORKER_THREADS_AVAILABLE, } from "./worker_threads.js";
+// The worker script: a self-contained mirror of the hot path of
+// src/utils/fast-safe-stringify/index.ts#serialize(). We deliberately
+// don't import the TS module -- the worker runs as a standalone script.
+const WORKER_SOURCE = /* js */ `
+const { parentPort } = require("worker_threads");
+
+const CIRCULAR_REPLACE_NODE = { result: "[Circular]" };
+
+function serializeWellKnownTypes(val) {
+  if (val && typeof val === "object") {
+    if (val instanceof Map) return Object.fromEntries(val);
+    if (val instanceof Set) return Array.from(val);
+    if (val instanceof Date) return val.toISOString();
+    if (val instanceof RegExp) return val.toString();
+    if (val instanceof Error) return { name: val.name, message: val.message };
+  } else if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+
+function defaultReplacer(_key, val) {
+  return serializeWellKnownTypes(val);
+}
+
+// Decirculate in-place: replace circular refs with { result: "[Circular]" }
+// then restore after stringify. Mirrors fast-safe-stringify's decirc().
+const restoreStack = [];
+function decirc(val, k, stack, parent) {
+  if (typeof val === "object" && val !== null) {
+    for (let i = 0; i < stack.length; i++) {
+      if (stack[i] === val) {
+        const orig = parent[k];
+        parent[k] = CIRCULAR_REPLACE_NODE;
+        restoreStack.push([parent, k, orig]);
+        return;
+      }
+    }
+    stack.push(val);
+    if (Array.isArray(val)) {
+      for (let i = 0; i < val.length; i++) decirc(val[i], i, stack, val);
+    } else {
+      const normalized = serializeWellKnownTypes(val);
+      // Only recurse into normalized if it's still an object (arrays/objects),
+      // else it was replaced with a primitive (e.g. Date -> string).
+      if (normalized === val) {
+        const keys = Object.keys(val);
+        for (let i = 0; i < keys.length; i++) decirc(val[keys[i]], keys[i], stack, val);
+      }
+    }
+    stack.pop();
+  }
+}
+
+function serialize(obj) {
+  try {
+    return JSON.stringify(obj, defaultReplacer);
+  } catch (e) {
+    if (!String(e && e.message).includes("Converting circular structure to JSON")) {
+      return "[Unserializable]";
+    }
+    decirc(obj, "", [], { "": obj });
+    try {
+      return JSON.stringify(obj, defaultReplacer);
+    } catch (_) {
+      return "[unable to serialize, circular reference is too complex to analyze]";
+    } finally {
+      while (restoreStack.length) {
+        const [p, k, v] = restoreStack.pop();
+        p[k] = v;
+      }
+    }
+  }
+}
+
+parentPort.on("message", (msg) => {
+  const { id, op, payload } = msg;
+  try {
+    if (op === "serialize") {
+      const str = serialize(payload);
+      const buf = Buffer.from(str, "utf8");
+      // Slice into its own ArrayBuffer so we can transfer without dragging
+      // unrelated bytes from any shared pool buffer.
+      const ab = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+      parentPort.postMessage({ id, bytes: ab, length: buf.byteLength }, [ab]);
+    } else if (op === "ping") {
+      parentPort.postMessage({ id });
+    } else {
+      parentPort.postMessage({ id, error: "unknown op: " + op });
+    }
+  } catch (e) {
+    parentPort.postMessage({ id, error: String((e && e.message) || e) });
+  }
+});
+`;
+export class SerializeWorker {
+    constructor() {
+        Object.defineProperty(this, "worker", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "nextId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "pending", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "startPromise", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    /**
+     * Try to construct the worker. Returns false if the runtime can't support
+     * it -- in that case callers must fall back to synchronous serialization.
+     * Kept async so callers don't have to branch on runtime -- the promise
+     * resolves synchronously on the microtask queue when the worker module
+     * is available, which is the common Node CJS/ESM path.
+     */
+    async ensureStarted() {
+        if (this.disabled)
+            return false;
+        if (this.worker !== null)
+            return true;
+        if (this.startPromise !== null)
+            return this.startPromise;
+        this.startPromise = this._start();
+        try {
+            return await this.startPromise;
+        }
+        finally {
+            this.startPromise = null;
+        }
+    }
+    async _start() {
+        // In browser / edge builds the `worker_threads` module is swapped with
+        // a stub that reports unavailability via the package.json `browser`
+        // field. Bail out before touching any Node-only surface.
+        if (!WORKER_THREADS_AVAILABLE || WorkerCtor === null) {
+            this.disabled = true;
+            return false;
+        }
+        try {
+            const worker = new WorkerCtor(WORKER_SOURCE, { eval: true });
+            worker.on("message", (msg) => {
+                const p = this.pending.get(msg.id);
+                if (!p)
+                    return;
+                this.pending.delete(msg.id);
+                if (msg.error) {
+                    p.reject(new Error(msg.error));
+                }
+                else if (msg.bytes && typeof msg.length === "number") {
+                    p.resolve(new Uint8Array(msg.bytes, 0, msg.length));
+                }
+                else {
+                    p.reject(new Error("worker returned malformed message"));
+                }
+            });
+            worker.on("error", (err) => {
+                // Reject all pending and disable; caller will fall back.
+                for (const [, p] of this.pending)
+                    p.reject(err);
+                this.pending.clear();
+                this.disabled = true;
+                this.worker = null;
+            });
+            worker.on("exit", (code) => {
+                // Reject all pending requests regardless of exit code. Even a clean
+                // exit (code 0) with in-flight requests means those promises would
+                // otherwise hang forever.
+                for (const [, p] of this.pending) {
+                    p.reject(new Error(`worker exited with code ${code}`));
+                }
+                this.pending.clear();
+                this.worker = null;
+            });
+            // Don't let the worker keep the process alive.
+            worker.unref();
+            this.worker = worker;
+            return true;
+        }
+        catch {
+            this.disabled = true;
+            return false;
+        }
+    }
+    /**
+     * Serialize a payload off-thread. Rejects with DataCloneError (or similar)
+     * if the payload contains non-cloneable values -- callers must catch and
+     * fall back to synchronous serialize().
+     *
+     * Resolves with null if the worker subsystem is unavailable entirely,
+     * so the caller can fall back without paying try/catch overhead.
+     */
+    async serialize(payload) {
+        const ok = await this.ensureStarted();
+        if (!ok)
+            return null;
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this.worker.postMessage({ id, op: "serialize", payload });
+            }
+            catch (e) {
+                // postMessage throws synchronously for DataCloneError, unclonable
+                // values, detached buffers, etc.
+                this.pending.delete(id);
+                reject(e);
+            }
+        });
+    }
+    async terminate() {
+        if (this.worker) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            await this.worker.terminate();
+            this.worker = null;
+        }
+        for (const [, p] of this.pending) {
+            p.reject(new Error("worker terminated"));
+        }
+        this.pending.clear();
+    }
+}
+let sharedWorker = null;
+/**
+ * Process-wide shared worker. One worker serves all Client instances to
+ * avoid spawning multiple threads per process.
+ */
+export function getSharedSerializeWorker() {
+    if (sharedWorker === null)
+        sharedWorker = new SerializeWorker();
+    return sharedWorker;
+}
+/**
+ * Minimum string length (in UTF-16 code units) that justifies the overhead
+ * of dispatching serialization to a worker thread.
+ *
+ * Rationale: V8's postMessage / structuredClone fast-paths large strings
+ * across isolates by refcounting their underlying storage rather than
+ * copying the bytes. This makes worker offload a big win for payloads
+ * dominated by a handful of multi-hundred-KB strings (the classic case is
+ * base64-encoded images or audio in LLM messages), but a net loss for
+ * payloads whose bulk is structural -- thousands of keys, deep nesting,
+ * many small strings -- because every object node must still be walked
+ * and cloned.
+ *
+ * 64KB sits comfortably above typical "chunk of agent state" or "long
+ * prompt" values (a few KB) and below typical base64 media payloads
+ * (hundreds of KB to several MB).
+ */
+const LARGE_STRING_THRESHOLD = 64 * 1024;
+/**
+ * Maximum number of nodes to inspect before giving up and assuming the
+ * payload is not worth offloading. Prevents the check itself from becoming
+ * expensive on pathologically structural payloads (many thousands of small
+ * keys / array elements).
+ *
+ * When the budget is exhausted without finding a large string we return
+ * false (do not offload). This is the conservative choice: such payloads
+ * are structural by nature and worker offload empirically regresses them.
+ */
+const NODE_BUDGET = 2048;
+/**
+ * Cheap, short-circuiting walk that returns true iff the payload contains
+ * at least one string of length >= threshold anywhere in its graph.
+ *
+ * - Terminates immediately on the first qualifying string.
+ * - Caps total nodes visited at `nodeBudget` so cost is bounded for huge
+ *   structural payloads.
+ * - Avoids allocation in the common path: uses an array as a stack and a
+ *   Set only for cycle detection.
+ * - Uses `string.length` (UTF-16 units), not UTF-8 byte length, because
+ *   that's what V8's string-sharing fast path keys on and because it's
+ *   an O(1) property access. For ASCII content this is identical to the
+ *   UTF-8 byte count; for non-ASCII text the two differ by at most 4x,
+ *   well within the safety margin of the threshold.
+ */
+export function hasLargeString(value, threshold = LARGE_STRING_THRESHOLD, nodeBudget = NODE_BUDGET) {
+    if (value === null || typeof value !== "object") {
+        return typeof value === "string" && value.length >= threshold;
+    }
+    const stack = [value];
+    const seen = new Set();
+    let visited = 0;
+    while (stack.length > 0) {
+        if (visited++ >= nodeBudget)
+            return false;
+        const cur = stack.pop();
+        if (cur === null || cur === undefined)
+            continue;
+        const t = typeof cur;
+        if (t === "string") {
+            if (cur.length >= threshold)
+                return true;
+            continue;
+        }
+        if (t !== "object")
+            continue;
+        const obj = cur;
+        if (seen.has(obj))
+            continue;
+        seen.add(obj);
+        // Skip well-known opaque types -- none of their enumerable own
+        // properties produce large strings in practice, and ArrayBuffer views
+        // would inflate the node budget if iterated element by element.
+        /* eslint-disable no-instanceof/no-instanceof */
+        if (obj instanceof Date ||
+            obj instanceof RegExp ||
+            obj instanceof Error ||
+            obj instanceof ArrayBuffer ||
+            ArrayBuffer.isView(obj)) {
+            continue;
+        }
+        if (Array.isArray(obj)) {
+            // Iterate in reverse so the first element is popped first (stable
+            // left-to-right discovery order, harmless but nice for predictable
+            // short-circuits in tests).
+            for (let i = obj.length - 1; i >= 0; i--)
+                stack.push(obj[i]);
+            continue;
+        }
+        if (obj instanceof Map) {
+            for (const [, v] of obj)
+                stack.push(v);
+            continue;
+        }
+        if (obj instanceof Set) {
+            for (const v of obj)
+                stack.push(v);
+            continue;
+        }
+        /* eslint-enable no-instanceof/no-instanceof */
+        // Push keys in reverse so they pop in declared order. Combined with
+        // the similar reverse-push for arrays above, this makes discovery
+        // order a stable depth-first walk in source order -- which matters
+        // for predictable short-circuit behavior under a node budget.
+        const keys = Object.keys(obj);
+        for (let i = keys.length - 1; i >= 0; i--) {
+            stack.push(obj[keys[i]]);
+        }
+    }
+    return false;
+}

package/dist/utils/uuid/src/index.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = exports.validate = exports.v7 = exports.v5 = exports.v4 = exports.stringify = exports.parse = exports.NIL = exports.MAX = void 0;
+var max_js_1 = require("./max.cjs");
+Object.defineProperty(exports, "MAX", { enumerable: true, get: function () { return __importDefault(max_js_1).default; } });
+var nil_js_1 = require("./nil.cjs");
+Object.defineProperty(exports, "NIL", { enumerable: true, get: function () { return __importDefault(nil_js_1).default; } });
+var parse_js_1 = require("./parse.cjs");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return __importDefault(parse_js_1).default; } });
+var stringify_js_1 = require("./stringify.cjs");
+Object.defineProperty(exports, "stringify", { enumerable: true, get: function () { return __importDefault(stringify_js_1).default; } });
+var v4_js_1 = require("./v4.cjs");
+Object.defineProperty(exports, "v4", { enumerable: true, get: function () { return __importDefault(v4_js_1).default; } });
+var v5_js_1 = require("./v5.cjs");
+Object.defineProperty(exports, "v5", { enumerable: true, get: function () { return __importDefault(v5_js_1).default; } });
+var v7_js_1 = require("./v7.cjs");
+Object.defineProperty(exports, "v7", { enumerable: true, get: function () { return __importDefault(v7_js_1).default; } });
+var validate_js_1 = require("./validate.cjs");
+Object.defineProperty(exports, "validate", { enumerable: true, get: function () { return __importDefault(validate_js_1).default; } });
+var version_js_1 = require("./version.cjs");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return __importDefault(version_js_1).default; } });

package/dist/utils/uuid/src/index.d.ts

@@ -0,0 +1,10 @@
+export { default as MAX } from "./max.js";
+export { default as NIL } from "./nil.js";
+export { default as parse } from "./parse.js";
+export { default as stringify } from "./stringify.js";
+export type * from "./types.js";
+export { default as v4 } from "./v4.js";
+export { default as v5 } from "./v5.js";
+export { default as v7 } from "./v7.js";
+export { default as validate } from "./validate.js";
+export { default as version } from "./version.js";

package/dist/utils/uuid/src/index.js

@@ -0,0 +1,9 @@
+export { default as MAX } from "./max.js";
+export { default as NIL } from "./nil.js";
+export { default as parse } from "./parse.js";
+export { default as stringify } from "./stringify.js";
+export { default as v4 } from "./v4.js";
+export { default as v5 } from "./v5.js";
+export { default as v7 } from "./v7.js";
+export { default as validate } from "./validate.js";
+export { default as version } from "./version.js";

package/dist/utils/uuid/src/max.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = "ffffffff-ffff-ffff-ffff-ffffffffffff";

package/dist/utils/uuid/src/max.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "ffffffff-ffff-ffff-ffff-ffffffffffff";
+export default _default;

package/dist/utils/uuid/src/max.js

@@ -0,0 +1 @@
+export default "ffffffff-ffff-ffff-ffff-ffffffffffff";

package/dist/utils/uuid/src/nil.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = "00000000-0000-0000-0000-000000000000";

package/dist/utils/uuid/src/nil.d.ts

@@ -0,0 +1,2 @@
+declare const _default: "00000000-0000-0000-0000-000000000000";
+export default _default;

package/dist/utils/uuid/src/nil.js

@@ -0,0 +1 @@
+export default "00000000-0000-0000-0000-000000000000";

package/dist/utils/uuid/src/parse.cjs

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validate_js_1 = __importDefault(require("./validate.cjs"));
+function parse(uuid) {
+    if (!(0, validate_js_1.default)(uuid)) {
+        throw TypeError("Invalid UUID");
+    }
+    let v;
+    return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff, 
+    // Parse ........-####-....-....-............
+    (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-####-....-............
+    (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-....-####-............
+    (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-....-....-############
+    // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+    ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff, (v / 0x100000000) & 0xff, (v >>> 24) & 0xff, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff);
+}
+exports.default = parse;

package/dist/utils/uuid/src/parse.d.ts

@@ -0,0 +1,3 @@
+import type { NonSharedArrayBuffer } from "./types.js";
+declare function parse(uuid: string): NonSharedArrayBuffer;
+export default parse;

package/dist/utils/uuid/src/parse.js

@@ -0,0 +1,18 @@
+import validate from "./validate.js";
+function parse(uuid) {
+    if (!validate(uuid)) {
+        throw TypeError("Invalid UUID");
+    }
+    let v;
+    return Uint8Array.of((v = parseInt(uuid.slice(0, 8), 16)) >>> 24, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff, 
+    // Parse ........-####-....-....-............
+    (v = parseInt(uuid.slice(9, 13), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-####-....-............
+    (v = parseInt(uuid.slice(14, 18), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-....-####-............
+    (v = parseInt(uuid.slice(19, 23), 16)) >>> 8, v & 0xff, 
+    // Parse ........-....-....-....-############
+    // (Use "/" to avoid 32-bit truncation when bit-shifting high-order bytes)
+    ((v = parseInt(uuid.slice(24, 36), 16)) / 0x10000000000) & 0xff, (v / 0x100000000) & 0xff, (v >>> 24) & 0xff, (v >>> 16) & 0xff, (v >>> 8) & 0xff, v & 0xff);
+}
+export default parse;

package/dist/utils/uuid/src/regex.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

package/dist/utils/uuid/src/regex.d.ts

@@ -0,0 +1,2 @@
+declare const _default: RegExp;
+export default _default;

package/dist/utils/uuid/src/regex.js

@@ -0,0 +1 @@
+export default /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

package/dist/utils/uuid/src/rng.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = rng;
+// RNG values for use in UUID generation. This *must* use a high-quality source
+// of entropy, such as `crypto.getRandomValues()`.  And we reuse an array for
+// performance.
+const rnds8 = new Uint8Array(16);
+function rng() {
+    return crypto.getRandomValues(rnds8);
+}

package/dist/utils/uuid/src/rng.d.ts

@@ -0,0 +1 @@
+export default function rng(): Uint8Array<ArrayBuffer>;

package/dist/utils/uuid/src/rng.js

@@ -0,0 +1,7 @@
+// RNG values for use in UUID generation. This *must* use a high-quality source
+// of entropy, such as `crypto.getRandomValues()`.  And we reuse an array for
+// performance.
+const rnds8 = new Uint8Array(16);
+export default function rng() {
+    return crypto.getRandomValues(rnds8);
+}

package/dist/utils/uuid/src/sha1.cjs

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Adapted from Chris Veness' SHA1 code at
+// http://www.movable-type.co.uk/scripts/sha1.html
+function f(s, x, y, z) {
+    switch (s) {
+        case 0:
+            return (x & y) ^ (~x & z);
+        case 1:
+            return x ^ y ^ z;
+        case 2:
+            return (x & y) ^ (x & z) ^ (y & z);
+        case 3:
+            return x ^ y ^ z;
+    }
+}
+function ROTL(x, n) {
+    return (x << n) | (x >>> (32 - n));
+}
+function sha1(bytes) {
+    const K = [0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xca62c1d6];
+    const H = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+    const newBytes = new Uint8Array(bytes.length + 1);
+    newBytes.set(bytes);
+    newBytes[bytes.length] = 0x80;
+    bytes = newBytes;
+    const l = bytes.length / 4 + 2;
+    const N = Math.ceil(l / 16);
+    const M = new Array(N);
+    for (let i = 0; i < N; ++i) {
+        const arr = new Uint32Array(16);
+        for (let j = 0; j < 16; ++j) {
+            arr[j] =
+                (bytes[i * 64 + j * 4] << 24) |
+                    (bytes[i * 64 + j * 4 + 1] << 16) |
+                    (bytes[i * 64 + j * 4 + 2] << 8) |
+                    bytes[i * 64 + j * 4 + 3];
+        }
+        M[i] = arr;
+    }
+    M[N - 1][14] = ((bytes.length - 1) * 8) / 2 ** 32;
+    M[N - 1][14] = Math.floor(M[N - 1][14]);
+    M[N - 1][15] = ((bytes.length - 1) * 8) & 0xffffffff;
+    for (let i = 0; i < N; ++i) {
+        const W = new Uint32Array(80);
+        for (let t = 0; t < 16; ++t) {
+            W[t] = M[i][t];
+        }
+        for (let t = 16; t < 80; ++t) {
+            W[t] = ROTL(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1);
+        }
+        let a = H[0];
+        let b = H[1];
+        let c = H[2];
+        let d = H[3];
+        let e = H[4];
+        for (let t = 0; t < 80; ++t) {
+            const s = Math.floor(t / 20);
+            const T = (ROTL(a, 5) + f(s, b, c, d) + e + K[s] + W[t]) >>> 0;
+            e = d;
+            d = c;
+            c = ROTL(b, 30) >>> 0;
+            b = a;
+            a = T;
+        }
+        H[0] = (H[0] + a) >>> 0;
+        H[1] = (H[1] + b) >>> 0;
+        H[2] = (H[2] + c) >>> 0;
+        H[3] = (H[3] + d) >>> 0;
+        H[4] = (H[4] + e) >>> 0;
+    }
+    // Note: Uint8Array.of() does `& 0xff` for each value
+    return Uint8Array.of(H[0] >> 24, H[0] >> 16, H[0] >> 8, H[0], H[1] >> 24, H[1] >> 16, H[1] >> 8, H[1], H[2] >> 24, H[2] >> 16, H[2] >> 8, H[2], H[3] >> 24, H[3] >> 16, H[3] >> 8, H[3], H[4] >> 24, H[4] >> 16, H[4] >> 8, H[4]);
+}
+exports.default = sha1;

package/dist/utils/uuid/src/sha1.d.ts

@@ -0,0 +1,2 @@
+declare function sha1(bytes: Uint8Array): Uint8Array;
+export default sha1;