langsmith 0.10.9 → 0.10.10

package/src/lib/utils/serialize_worker.ts

@@ -0,0 +1,374 @@
+/**
+ * Off-thread serialization using Node worker_threads.
+ *
+ * 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,
+  type WorkerLike,
+} 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) });
+  }
+});
+`;
+
+type Pending = {
+  resolve: (bytes: Uint8Array<ArrayBuffer>) => void;
+  reject: (err: Error) => void;
+};
+
+export class SerializeWorker {
+  private worker: WorkerLike | null = null;
+  private nextId = 1;
+  private pending = new Map<number, Pending>();
+  private disabled = false;
+  private startPromise: Promise<boolean> | null = 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.
+   */
+  private async ensureStarted(): Promise<boolean> {
+    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;
+    }
+  }
+
+  private async _start(): Promise<boolean> {
+    // 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: {
+          id: number;
+          bytes?: ArrayBuffer;
+          length?: number;
+          error?: string;
+        }) => {
+          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,
+              ) as Uint8Array<ArrayBuffer>,
+            );
+          } else {
+            p.reject(new Error("worker returned malformed message"));
+          }
+        },
+      );
+      worker.on("error", (err: Error) => {
+        // 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: number) => {
+        // 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: unknown): Promise<Uint8Array<ArrayBuffer> | null> {
+    const ok = await this.ensureStarted();
+    if (!ok) return null;
+    const id = this.nextId++;
+    return new Promise<Uint8Array<ArrayBuffer>>((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (this.worker as any).postMessage({ id, op: "serialize", payload });
+      } catch (e) {
+        // postMessage throws synchronously for DataCloneError, unclonable
+        // values, detached buffers, etc.
+        this.pending.delete(id);
+        reject(e as Error);
+      }
+    });
+  }
+
+  async terminate(): Promise<void> {
+    if (this.worker) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      await (this.worker as any).terminate();
+      this.worker = null;
+    }
+    for (const [, p] of this.pending) {
+      p.reject(new Error("worker terminated"));
+    }
+    this.pending.clear();
+  }
+}
+
+let sharedWorker: SerializeWorker | null = null;
+
+/**
+ * Process-wide shared worker. One worker serves all Client instances to
+ * avoid spawning multiple threads per process.
+ */
+export function getSharedSerializeWorker(): SerializeWorker {
+  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: unknown,
+  threshold: number = LARGE_STRING_THRESHOLD,
+  nodeBudget: number = NODE_BUDGET,
+): boolean {
+  if (value === null || typeof value !== "object") {
+    return typeof value === "string" && value.length >= threshold;
+  }
+  const stack: unknown[] = [value];
+  const seen = new Set<object>();
+  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 as string).length >= threshold) return true;
+      continue;
+    }
+    if (t !== "object") continue;
+    const obj = cur as object;
+    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.
+    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;
+    }
+    // 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 as Record<string, unknown>)[keys[i]]);
+    }
+  }
+  return false;
+}

package/src/lib/utils/shuffle.ts

@@ -0,0 +1,13 @@
+export function shuffle<T extends unknown[]>(array: T): T {
+  let currentIndex = array.length;
+  while (currentIndex !== 0) {
+    const randomIndex = Math.floor(Math.random() * currentIndex);
+    currentIndex -= 1;
+
+    const tmp = array[currentIndex];
+    array[currentIndex] = array[randomIndex];
+    array[randomIndex] = tmp;
+  }
+
+  return array;
+}

package/src/lib/utils/simple-wcswidth/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Nahiyan Kamal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/src/lib/utils/simple-wcswidth/index.ts

@@ -0,0 +1,4 @@
+import wcswidth from './src/wcswidth.js';
+import wcwidth from './src/wcwidth.js';
+
+export { wcwidth, wcswidth };

package/src/lib/utils/simple-wcswidth/src/binary-search.ts

@@ -0,0 +1,29 @@
+import { Interval } from './models.js';
+
+/* auxiliary function for binary search in interval table */
+const bisearch = (
+  ucs: number,
+  table: Interval[],
+  tableSize: number
+): number => {
+  let min = 0;
+  let mid: number;
+  let max = tableSize;
+
+  if (ucs < table[0].first || ucs > table[max].last) return 0;
+
+  while (max >= min) {
+    mid = Math.floor((min + max) / 2);
+    if (ucs > table[mid].last) {
+      min = mid + 1;
+    } else if (ucs < table[mid].first) {
+      max = mid - 1;
+    } else {
+      return 1;
+    }
+  }
+
+  return 0;
+};
+
+export default bisearch;

package/src/lib/utils/simple-wcswidth/src/models.ts

@@ -0,0 +1,4 @@
+export interface Interval {
+  first: number;
+  last: number;
+}

package/src/lib/utils/simple-wcswidth/src/non-spacing-chars.ts

@@ -0,0 +1,150 @@
+import { Interval } from './models.js';
+
+/* sorted list of non-overlapping intervals of non-spacing characters */
+/* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
+const combining: Interval[] = [
+  { first: 0x0300, last: 0x036f },
+  { first: 0x0483, last: 0x0486 },
+  { first: 0x0488, last: 0x0489 },
+  { first: 0x0591, last: 0x05bd },
+  { first: 0x05bf, last: 0x05bf },
+  { first: 0x05c1, last: 0x05c2 },
+  { first: 0x05c4, last: 0x05c5 },
+  { first: 0x05c7, last: 0x05c7 },
+  { first: 0x0600, last: 0x0603 },
+  { first: 0x0610, last: 0x0615 },
+  { first: 0x064b, last: 0x065e },
+  { first: 0x0670, last: 0x0670 },
+  { first: 0x06d6, last: 0x06e4 },
+  { first: 0x06e7, last: 0x06e8 },
+  { first: 0x06ea, last: 0x06ed },
+  { first: 0x070f, last: 0x070f },
+  { first: 0x0711, last: 0x0711 },
+  { first: 0x0730, last: 0x074a },
+  { first: 0x07a6, last: 0x07b0 },
+  { first: 0x07eb, last: 0x07f3 },
+  { first: 0x0901, last: 0x0902 },
+  { first: 0x093c, last: 0x093c },
+  { first: 0x0941, last: 0x0948 },
+  { first: 0x094d, last: 0x094d },
+  { first: 0x0951, last: 0x0954 },
+  { first: 0x0962, last: 0x0963 },
+  { first: 0x0981, last: 0x0981 },
+  { first: 0x09bc, last: 0x09bc },
+  { first: 0x09c1, last: 0x09c4 },
+  { first: 0x09cd, last: 0x09cd },
+  { first: 0x09e2, last: 0x09e3 },
+  { first: 0x0a01, last: 0x0a02 },
+  { first: 0x0a3c, last: 0x0a3c },
+  { first: 0x0a41, last: 0x0a42 },
+  { first: 0x0a47, last: 0x0a48 },
+  { first: 0x0a4b, last: 0x0a4d },
+  { first: 0x0a70, last: 0x0a71 },
+  { first: 0x0a81, last: 0x0a82 },
+  { first: 0x0abc, last: 0x0abc },
+  { first: 0x0ac1, last: 0x0ac5 },
+  { first: 0x0ac7, last: 0x0ac8 },
+  { first: 0x0acd, last: 0x0acd },
+  { first: 0x0ae2, last: 0x0ae3 },
+  { first: 0x0b01, last: 0x0b01 },
+  { first: 0x0b3c, last: 0x0b3c },
+  { first: 0x0b3f, last: 0x0b3f },
+  { first: 0x0b41, last: 0x0b43 },
+  { first: 0x0b4d, last: 0x0b4d },
+  { first: 0x0b56, last: 0x0b56 },
+  { first: 0x0b82, last: 0x0b82 },
+  { first: 0x0bc0, last: 0x0bc0 },
+  { first: 0x0bcd, last: 0x0bcd },
+  { first: 0x0c3e, last: 0x0c40 },
+  { first: 0x0c46, last: 0x0c48 },
+  { first: 0x0c4a, last: 0x0c4d },
+  { first: 0x0c55, last: 0x0c56 },
+  { first: 0x0cbc, last: 0x0cbc },
+  { first: 0x0cbf, last: 0x0cbf },
+  { first: 0x0cc6, last: 0x0cc6 },
+  { first: 0x0ccc, last: 0x0ccd },
+  { first: 0x0ce2, last: 0x0ce3 },
+  { first: 0x0d41, last: 0x0d43 },
+  { first: 0x0d4d, last: 0x0d4d },
+  { first: 0x0dca, last: 0x0dca },
+  { first: 0x0dd2, last: 0x0dd4 },
+  { first: 0x0dd6, last: 0x0dd6 },
+  { first: 0x0e31, last: 0x0e31 },
+  { first: 0x0e34, last: 0x0e3a },
+  { first: 0x0e47, last: 0x0e4e },
+  { first: 0x0eb1, last: 0x0eb1 },
+  { first: 0x0eb4, last: 0x0eb9 },
+  { first: 0x0ebb, last: 0x0ebc },
+  { first: 0x0ec8, last: 0x0ecd },
+  { first: 0x0f18, last: 0x0f19 },
+  { first: 0x0f35, last: 0x0f35 },
+  { first: 0x0f37, last: 0x0f37 },
+  { first: 0x0f39, last: 0x0f39 },
+  { first: 0x0f71, last: 0x0f7e },
+  { first: 0x0f80, last: 0x0f84 },
+  { first: 0x0f86, last: 0x0f87 },
+  { first: 0x0f90, last: 0x0f97 },
+  { first: 0x0f99, last: 0x0fbc },
+  { first: 0x0fc6, last: 0x0fc6 },
+  { first: 0x102d, last: 0x1030 },
+  { first: 0x1032, last: 0x1032 },
+  { first: 0x1036, last: 0x1037 },
+  { first: 0x1039, last: 0x1039 },
+  { first: 0x1058, last: 0x1059 },
+  { first: 0x1160, last: 0x11ff },
+  { first: 0x135f, last: 0x135f },
+  { first: 0x1712, last: 0x1714 },
+  { first: 0x1732, last: 0x1734 },
+  { first: 0x1752, last: 0x1753 },
+  { first: 0x1772, last: 0x1773 },
+  { first: 0x17b4, last: 0x17b5 },
+  { first: 0x17b7, last: 0x17bd },
+  { first: 0x17c6, last: 0x17c6 },
+  { first: 0x17c9, last: 0x17d3 },
+  { first: 0x17dd, last: 0x17dd },
+  { first: 0x180b, last: 0x180d },
+  { first: 0x18a9, last: 0x18a9 },
+  { first: 0x1920, last: 0x1922 },
+  { first: 0x1927, last: 0x1928 },
+  { first: 0x1932, last: 0x1932 },
+  { first: 0x1939, last: 0x193b },
+  { first: 0x1a17, last: 0x1a18 },
+  { first: 0x1b00, last: 0x1b03 },
+  { first: 0x1b34, last: 0x1b34 },
+  { first: 0x1b36, last: 0x1b3a },
+  { first: 0x1b3c, last: 0x1b3c },
+  { first: 0x1b42, last: 0x1b42 },
+  { first: 0x1b6b, last: 0x1b73 },
+  { first: 0x1dc0, last: 0x1dca },
+  { first: 0x1dfe, last: 0x1dff },
+  { first: 0x200b, last: 0x200f },
+  { first: 0x202a, last: 0x202e },
+  { first: 0x2060, last: 0x2063 },
+  { first: 0x206a, last: 0x206f },
+  { first: 0x20d0, last: 0x20ef },
+  { first: 0x302a, last: 0x302f },
+  { first: 0x3099, last: 0x309a },
+  { first: 0xa806, last: 0xa806 },
+  { first: 0xa80b, last: 0xa80b },
+  { first: 0xa825, last: 0xa826 },
+  { first: 0xfb1e, last: 0xfb1e },
+  { first: 0xfe00, last: 0xfe0f },
+  { first: 0xfe20, last: 0xfe23 },
+  { first: 0xfeff, last: 0xfeff },
+  { first: 0xfff9, last: 0xfffb },
+  { first: 0x10a01, last: 0x10a03 },
+  { first: 0x10a05, last: 0x10a06 },
+  { first: 0x10a0c, last: 0x10a0f },
+  { first: 0x10a38, last: 0x10a3a },
+  { first: 0x10a3f, last: 0x10a3f },
+  { first: 0x1d167, last: 0x1d169 },
+  { first: 0x1d173, last: 0x1d182 },
+  { first: 0x1d185, last: 0x1d18b },
+  { first: 0x1d1aa, last: 0x1d1ad },
+  { first: 0x1d242, last: 0x1d244 },
+  { first: 0xe0001, last: 0xe0001 },
+  { first: 0xe0020, last: 0xe007f },
+  { first: 0xe0100, last: 0xe01ef },
+];
+
+export default combining;

package/src/lib/utils/simple-wcswidth/src/wcswidth.ts

@@ -0,0 +1,19 @@
+import mk_wcwidth from './wcwidth.js';
+
+const mk_wcswidth = (pwcs: string) => {
+  let width = 0;
+
+  // eslint-disable-next-line no-plusplus
+  for (let i = 0; i < pwcs.length; i++) {
+    const charCode = pwcs.charCodeAt(i);
+    const w = mk_wcwidth(charCode);
+    if (w < 0) {
+      return -1;
+    }
+    width += w;
+  }
+
+  return width;
+};
+
+export default mk_wcswidth;

package/src/lib/utils/simple-wcswidth/src/wcwidth.ts

@@ -0,0 +1,72 @@
+import combining from './non-spacing-chars.js';
+import bisearch from './binary-search.js';
+
+/* The following two functions define the column width of an ISO 10646
+ * character as follows:
+ *
+ *    - The null character (U+0000) has a column width of 0.
+ *
+ *    - Other C0/C1 control characters and DEL will lead to a return
+ *      value of -1.
+ *
+ *    - Non-spacing and enclosing combining characters (general
+ *      category code Mn or Me in the Unicode database) have a
+ *      column width of 0.
+ *
+ *    - SOFT HYPHEN (U+00AD) has a column width of 1.
+ *
+ *    - Other format characters (general category code Cf in the Unicode
+ *      database) and ZERO WIDTH SPACE (U+200B) have a column width of 0.
+ *
+ *    - Hangul Jamo medial vowels and final consonants (U+1160-U+11FF)
+ *      have a column width of 0.
+ *
+ *    - Spacing characters in the East Asian Wide (W) or East Asian
+ *      Full-width (F) category as defined in Unicode Technical
+ *      Report #11 have a column width of 2.
+ *
+ *    - All remaining characters (including all printable
+ *      ISO 8859-1 and WGL4 characters, Unicode control characters,
+ *      etc.) have a column width of 1.
+ *
+ * This implementation assumes that wchar_t characters are encoded
+ * in ISO 10646.
+ */
+
+const mk_wcwidth = (ucs: number): number => {
+  /* test for 8-bit control characters */
+  if (ucs === 0) {
+    return 0;
+  }
+  if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0)) {
+    return -1;
+  }
+
+  /* binary search in table of non-spacing characters */
+  if (bisearch(ucs, combining, combining.length - 1)) {
+    return 0;
+  }
+
+  /* if we arrive here, ucs is not a combining or C0/C1 control character */
+
+  return (
+    1 +
+    Number(
+      ucs >= 0x1100 &&
+        (ucs <= 0x115f /* Hangul Jamo init. consonants */ ||
+          ucs === 0x2329 ||
+          ucs === 0x232a ||
+          (ucs >= 0x2e80 && ucs <= 0xa4cf && ucs !== 0x303f) /* CJK ... Yi */ ||
+          (ucs >= 0xac00 && ucs <= 0xd7a3) /* Hangul Syllables */ ||
+          (ucs >= 0xf900 && ucs <= 0xfaff) /* CJK Compatibility Ideographs */ ||
+          (ucs >= 0xfe10 && ucs <= 0xfe19) /* Vertical forms */ ||
+          (ucs >= 0xfe30 && ucs <= 0xfe6f) /* CJK Compatibility Forms */ ||
+          (ucs >= 0xff00 && ucs <= 0xff60) /* Fullwidth Forms */ ||
+          (ucs >= 0xffe0 && ucs <= 0xffe6) ||
+          (ucs >= 0x20000 && ucs <= 0x2fffd) ||
+          (ucs >= 0x30000 && ucs <= 0x3fffd))
+    )
+  );
+};
+
+export default mk_wcwidth;