@codeworksh/aikit 0.4.0 → 0.4.1-dev.20260530133305

package/src/provider/providers/utils.ts

@@ -1,7 +0,0 @@
-import { Provider } from "../provider";
-
-// TODO @sanchitrk:
-// implement based for multiple providers
-export function getEnvApiKey(_provider: Provider.Info): string | undefined {
-	return undefined;
-}

package/src/provider/register.ts

@@ -1,6 +0,0 @@
-import anthropicProvider from "./providers/anthropic/index";
-import openAICompletionsProvider from "./providers/openai/completions";
-import { Stream } from "./stream";
-
-Stream.registerProtocolProvider(anthropicProvider, "providers/anthropic/index.ts");
-Stream.registerProtocolProvider(openAICompletionsProvider, "providers/openai/completions.ts");

package/src/provider/stream.ts

@@ -1,278 +0,0 @@
-import { NamedError } from "@codeworksh/utils";
-import Type, { type Static } from "typebox";
-import type { Message } from "../message/message";
-import { Model } from "../model/model";
-import type { AssistantMessageEventStream } from "../utils/eventstream";
-
-export namespace Stream {
-	export const ProtocolProviderNotFoundError = NamedError.create(
-		"ProtocolProviderNotFoundError",
-		Type.Object({
-			protocol: Model.KnownProtocolSchema,
-		}),
-	);
-	export type ProtocolProviderNotFoundError = InstanceType<typeof ProtocolProviderNotFoundError>;
-
-	export const ProtocolMismatchError = NamedError.create(
-		"ProtocolMismatchError",
-		Type.Object({
-			actual: Model.KnownProtocolSchema,
-			expected: Model.KnownProtocolSchema,
-		}),
-	);
-	export type ProtocolMismatchError = InstanceType<typeof ProtocolMismatchError>;
-
-	export const ThinkingLevelEnum = {
-		off: "off",
-		minimal: "minimal",
-		low: "low",
-		medium: "medium",
-		high: "high",
-		xhigh: "xhigh",
-	} as const;
-	export const ThinkingLevelSchema = Type.Union([
-		Type.Literal(ThinkingLevelEnum.off),
-		Type.Literal(ThinkingLevelEnum.minimal),
-		Type.Literal(ThinkingLevelEnum.low),
-		Type.Literal(ThinkingLevelEnum.medium),
-		Type.Literal(ThinkingLevelEnum.high),
-		Type.Literal(ThinkingLevelEnum.xhigh),
-	]);
-	export type ThinkingLevel = Static<typeof ThinkingLevelSchema>;
-
-	export const ThinkingBudgetsSchema = Type.Object({
-		off: Type.Optional(Type.Number()),
-		minimal: Type.Optional(Type.Number()),
-		low: Type.Optional(Type.Number()),
-		medium: Type.Optional(Type.Number()),
-		high: Type.Optional(Type.Number()),
-	});
-	export type ThinkingBudgets = Static<typeof ThinkingBudgetsSchema>;
-
-	export const CacheRetentionSchema = Type.Union([Type.Literal("none"), Type.Literal("short"), Type.Literal("long")]);
-	export type CacheRetention = Static<typeof CacheRetentionSchema>;
-
-	export const TransportSchema = Type.Union([Type.Literal("sse"), Type.Literal("websocket"), Type.Literal("auto")]);
-	export type Transport = Static<typeof TransportSchema>;
-
-	export const OptionsSchema = Type.Object({
-		temperature: Type.Optional(Type.Number()),
-		maxTokens: Type.Optional(Type.Number()),
-		signal: Type.Optional(Type.Unsafe<AbortSignal>({})),
-		apiKey: Type.Optional(Type.String()),
-		transport: Type.Optional(TransportSchema),
-		cacheRetention: Type.Optional(CacheRetentionSchema),
-		sessionId: Type.Optional(Type.String()),
-		onPayload: Type.Optional(
-			Type.Unsafe<(payload: unknown, model: Model.TModel<Model.KnownProtocol>) => unknown>({}),
-		),
-		headers: Type.Optional(Type.Record(Type.String(), Type.String())),
-		maxRetryDelayMs: Type.Optional(Type.Number()),
-		metadata: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
-	});
-	export type Options = Static<typeof OptionsSchema>;
-	export type ProviderOptions = Options & Record<string, unknown>;
-
-	export const SimpleOptionsSchema = Type.Evaluate(
-		Type.Intersect([
-			OptionsSchema,
-			Type.Object({
-				reasoning: Type.Optional(ThinkingLevelSchema),
-				thinkingBudgets: Type.Optional(ThinkingBudgetsSchema),
-			}),
-		]),
-	);
-	export type SimpleOptions = Static<typeof SimpleOptionsSchema>;
-
-	// Contract:
-	// - Must return an AssistantMessageEventStream.
-	// - Once invoked, request/model/runtime failures should be encoded in the
-	//   returned stream, not thrown.
-	// - Error termination must produce an AssistantMessage with stopReason
-	//   "error" or "aborted" and errorMessage, emitted via the stream protocol.
-	export type StreamFunction<
-		TProtocol extends Model.KnownProtocol = Model.KnownProtocol,
-		TOptions extends Options = Options,
-	> = (model: Model.TModel<TProtocol>, context: Message.Context, options?: TOptions) => AssistantMessageEventStream;
-
-	export function buildBaseOptions(model: Model.Info, options?: SimpleOptions, apiKey?: string): Options {
-		return {
-			temperature: options?.temperature,
-			maxTokens: options?.maxTokens || Math.min(model.maxTokens, 32000),
-			signal: options?.signal,
-			apiKey: apiKey || options?.apiKey,
-			transport: options?.transport,
-			cacheRetention: options?.cacheRetention,
-			sessionId: options?.sessionId,
-			headers: options?.headers,
-			onPayload: options?.onPayload,
-			maxRetryDelayMs: options?.maxRetryDelayMs,
-			metadata: options?.metadata,
-		};
-	}
-
-	export function clampReasoning(effort: ThinkingLevel | undefined): Exclude<ThinkingLevel, "xhigh"> | undefined {
-		return effort === ThinkingLevelEnum.xhigh ? ThinkingLevelEnum.high : effort;
-	}
-
-	export function adjustMaxTokensForThinking(
-		baseMaxTokens: number,
-		modelMaxTokens: number,
-		reasoningLevel: ThinkingLevel,
-		customBudgets?: ThinkingBudgets,
-	): { maxTokens: number; thinkingBudget: number } {
-		const defaultBudgets: ThinkingBudgets = {
-			minimal: 1024,
-			low: 2048,
-			medium: 8192,
-			high: 16384,
-		};
-		const budgets = { ...defaultBudgets, ...customBudgets };
-		const minOutputTokens = 1024;
-		const level = clampReasoning(reasoningLevel)!;
-		let thinkingBudget = budgets[level]!;
-		const maxTokens = Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
-
-		if (maxTokens <= thinkingBudget) {
-			thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
-		}
-
-		return { maxTokens, thinkingBudget };
-	}
-
-	export type ProtocolStreamFunction = (
-		model: Model.Info,
-		context: Message.Context,
-		options?: Options,
-	) => AssistantMessageEventStream;
-
-	export type ProtocolStreamSimpleFunction = (
-		model: Model.Info,
-		context: Message.Context,
-		options?: SimpleOptions,
-	) => AssistantMessageEventStream;
-
-	export interface ProtocolProvider<
-		TProtocol extends Model.KnownProtocol = Model.KnownProtocol,
-		TOptions extends Options = Options,
-	> {
-		protocol: TProtocol;
-		stream: StreamFunction<TProtocol, TOptions>;
-		streamSimple: StreamFunction<TProtocol, SimpleOptions>;
-	}
-
-	type RegisteredProtocolProvider = {
-		provider: ProtocolProvider<Model.KnownProtocol, Options>;
-		sourceId?: string;
-	};
-
-	const protocolProviderRegistry = new Map<Model.KnownProtocol, RegisteredProtocolProvider>();
-
-	function wrapStream<TProtocol extends Model.KnownProtocol, TOptions extends Options>(
-		protocol: TProtocol,
-		stream: StreamFunction<TProtocol, TOptions>,
-	): ProtocolStreamFunction {
-		return (model, context, options) => {
-			if (model.protocol !== protocol) {
-				throw new ProtocolMismatchError({
-					actual: model.protocol,
-					expected: protocol,
-				});
-			}
-			return stream(model as Model.TModel<TProtocol>, context, options as TOptions);
-		};
-	}
-
-	function wrapStreamSimple<TProtocol extends Model.KnownProtocol>(
-		protocol: TProtocol,
-		streamSimple: StreamFunction<TProtocol, SimpleOptions>,
-	): ProtocolStreamSimpleFunction {
-		return (model, context, options) => {
-			if (model.protocol !== protocol) {
-				throw new ProtocolMismatchError({
-					actual: model.protocol,
-					expected: protocol,
-				});
-			}
-			return streamSimple(model as Model.TModel<TProtocol>, context, options);
-		};
-	}
-
-	export function registerProtocolProvider<TProtocol extends Model.KnownProtocol, TOptions extends Options>(
-		provider: ProtocolProvider<TProtocol, TOptions>,
-		sourceId?: string,
-	): void {
-		protocolProviderRegistry.set(provider.protocol, {
-			provider: {
-				protocol: provider.protocol,
-				stream: wrapStream(provider.protocol, provider.stream),
-				streamSimple: wrapStreamSimple(provider.protocol, provider.streamSimple),
-			},
-			sourceId,
-		});
-	}
-
-	export function getProtocolProvider(
-		protocol: Model.KnownProtocol,
-	): ProtocolProvider<Model.KnownProtocol, Options> | undefined {
-		return protocolProviderRegistry.get(protocol)?.provider;
-	}
-
-	export function resolveProtocolProvider(model: Model.Info): ProtocolProvider<Model.KnownProtocol, Options> {
-		const provider = getProtocolProvider(model.protocol);
-		if (!provider) {
-			throw new ProtocolProviderNotFoundError({
-				protocol: model.protocol,
-			});
-		}
-		return provider;
-	}
-
-	export function stream(model: Model.Info, context: Message.Context, options?: Options): AssistantMessageEventStream {
-		const provider = resolveProtocolProvider(model);
-		return provider.stream(model, context, options);
-	}
-
-	export async function complete(
-		model: Model.Info,
-		context: Message.Context,
-		options?: Options,
-	): Promise<Message.AssistantMessage> {
-		const s = stream(model, context, options);
-		return s.result();
-	}
-
-	export function streamSimple(
-		model: Model.Info,
-		context: Message.Context,
-		options?: SimpleOptions,
-	): AssistantMessageEventStream {
-		const provider = resolveProtocolProvider(model);
-		return provider.streamSimple(model, context, options);
-	}
-
-	export async function completeSimple(
-		model: Model.Info,
-		context: Message.Context,
-		options?: SimpleOptions,
-	): Promise<Message.AssistantMessage> {
-		const s = streamSimple(model, context, options);
-		return s.result();
-	}
-
-	export function getApiProviders(): ProtocolProvider<Model.KnownProtocol, Options>[] {
-		return Array.from(protocolProviderRegistry.values(), (entry) => entry.provider);
-	}
-
-	export function unregisterProtocolProviders(sourceId: string): void {
-		for (const [api, entry] of protocolProviderRegistry.entries()) {
-			if (entry.sourceId === sourceId) {
-				protocolProviderRegistry.delete(api);
-			}
-		}
-	}
-
-	export function clearProtocolProviders(): void {
-		protocolProviderRegistry.clear();
-	}
-}

package/src/stream.ts

@@ -1,72 +0,0 @@
-import "./provider/register";
-
-import type { Message } from "./message/message";
-import type { Model } from "./model/model";
-import { Stream } from "./provider/stream";
-import type { AssistantMessageEventStream } from "./utils/eventstream";
-
-/**
- * Stream assistant responses for a model and context.
- *
- * Example:
- *
- * ```ts
- * const s = stream(model, context, {
- *   apiKey: process.env.ANTHROPIC_API_KEY,
- * });
- *
- * for await (const event of s) {
- *   if (event.type === "text.delta") {
- *     process.stdout.write(event.delta);
- *   }
- * }
- *
- * const message = await s.result();
- * ```
- *
- * This export also includes convenience helpers:
- *
- * ```ts
- * const message = await stream.complete(model, context, options);
- * const simple = stream.simple(model, context, options);
- * const simpleMessage = await stream.completeSimple(model, context, options);
- * ```
- */
-type StreamCallable = {
-	(model: Model.Info, context: Message.Context, options?: Stream.Options): AssistantMessageEventStream;
-	complete: typeof Stream.complete;
-	simple: typeof Stream.streamSimple;
-	completeSimple: typeof Stream.completeSimple;
-	resolveProtocolProvider: typeof Stream.resolveProtocolProvider;
-};
-
-const streamImpl = (
-	model: Model.Info,
-	context: Message.Context,
-	options?: Stream.Options,
-): AssistantMessageEventStream => Stream.stream(model, context, options);
-
-/**
- * Start a streaming assistant response for a model/context pair.
- *
- * This is the main streaming entrypoint.
- * Attached helpers:
- *
- * - `stream.complete(...)` resolves the final assistant message without manually iterating events.
- * - `stream.simple(...)` uses `Stream.SimpleOptions` for higher-level reasoning controls.
- * - `stream.completeSimple(...)` is the non-streaming counterpart to `stream.simple(...)`.
- * - `stream.resolveProtocolProvider(...)` exposes protocol resolution for advanced integrations.
- */
-export const stream = Object.assign(streamImpl, {
-	complete: Stream.complete,
-	simple: Stream.streamSimple,
-	completeSimple: Stream.completeSimple,
-	resolveProtocolProvider: Stream.resolveProtocolProvider,
-}) as StreamCallable;
-
-/** Resolve a streamed response directly to the final assistant message. */
-export const complete = Stream.complete;
-/** Start a stream using the simplified options surface. */
-export const streamSimple = Stream.streamSimple;
-/** Resolve a simplified stream request directly to the final assistant message. */
-export const completeSimple = Stream.completeSimple;

package/src/utils/eventstream.ts

@@ -1,95 +0,0 @@
-/**
- * @description Defines the Generic event stream class for async iteration.
- */
-
-import type { Event } from "../event/event";
-import type { Message } from "../message/message";
-
-// Implements the async iterator pattern
-// LLM output are streams of events for consuming
-// This class helps with that by acting like buffer data structure to manage the streams
-// for producer and consumer
-export class EventStream<T, R = T> implements AsyncIterable<T> {
-	private queue: T[] = [];
-	private waiting: ((value: IteratorResult<T>) => void)[] = [];
-	private done = false;
-	private readonly finalResultPromise: Promise<R>;
-	private resolveFinalResult!: (result: R) => void;
-
-	constructor(
-		private isComplete: (event: T) => boolean,
-		private extractResult: (event: T) => R,
-	) {
-		this.finalResultPromise = new Promise((resolve) => {
-			this.resolveFinalResult = resolve;
-		});
-	}
-
-	push(event: T): void {
-		if (this.done) return;
-
-		if (this.isComplete(event)) {
-			this.done = true;
-			this.resolveFinalResult(this.extractResult(event));
-		}
-
-		// Deliver to waiting consumer or queue it
-		const waiter = this.waiting.shift();
-		if (waiter) {
-			waiter({ value: event, done: false });
-		} else {
-			this.queue.push(event);
-		}
-	}
-
-	end(result?: R): void {
-		this.done = true;
-		if (result !== undefined) {
-			this.resolveFinalResult(result);
-		}
-		// Notify all waiting consumers that we're done
-		while (this.waiting.length > 0) {
-			const waiter = this.waiting.shift()!;
-			waiter({ value: undefined as any, done: true });
-		}
-	}
-
-	async *[Symbol.asyncIterator](): AsyncIterator<T> {
-		while (true) {
-			if (this.queue.length > 0) {
-				yield this.queue.shift()!;
-			} else if (this.done) {
-				return;
-			} else {
-				const result = await new Promise<IteratorResult<T>>((resolve) => this.waiting.push(resolve));
-				if (result.done) return;
-				yield result.value;
-			}
-		}
-	}
-
-	result(): Promise<R> {
-		return this.finalResultPromise;
-	}
-}
-
-export class AssistantMessageEventStream extends EventStream<Event.LLMMessageEvent, Message.AssistantMessage> {
-	constructor() {
-		super(
-			(event) => event.type === "done" || event.type === "error",
-			(event) => {
-				if (event.type === "done") {
-					return event.message;
-				} else if (event.type === "error") {
-					return event.error;
-				}
-				throw new Error("Unexpected event type for final result");
-			},
-		);
-	}
-}
-
-/** Factory function for AssistantMessageEventStream (for use in extensions) */
-export function createAssistantMessageEventStream(): AssistantMessageEventStream {
-	return new AssistantMessageEventStream();
-}

package/src/utils/helpers.ts

@@ -1,24 +0,0 @@
-import Type, { type TUnsafe } from "typebox";
-
-/**
- * Creates a string enum schema compatible with Google's API and other providers
- * that don't support anyOf/const patterns.
- *
- * @example
- * const OperationSchema = StringEnum(["add", "subtract", "multiply", "divide"], {
- *   description: "The operation to perform"
- * });
- *
- * type Operation = Static<typeof OperationSchema>; // "add" | "subtract" | "multiply" | "divide"
- */
-export function StringEnum<T extends readonly string[]>(
-	values: T,
-	options?: { description?: string; default?: T[number] },
-): TUnsafe<T[number]> {
-	return Type.Unsafe<T[number]>({
-		type: "string",
-		enum: values as any,
-		...(options?.description && { description: options.description }),
-		...(options?.default && { default: options.default }),
-	});
-}

package/src/utils/jsonparse.ts

@@ -1,32 +0,0 @@
-/**
- * @description Helper function to parse partial jsons during LLM streaming.
- */
-
-import { parse as partialParse } from "partial-json";
-
-/**
- * Attempts to parse potentially incomplete JSON during streaming.
- * Always returns a valid object, even if the JSON is incomplete.
- *
- * @param partialJson The partial JSON string from streaming
- * @returns Parsed object or empty object if parsing fails
- */
-export function parseStreamingJson<T = any>(partialJson: string | undefined): T {
-	if (!partialJson || partialJson.trim() === "") {
-		return {} as T;
-	}
-
-	// Try standard parsing first (fastest for complete JSON)
-	try {
-		return JSON.parse(partialJson) as T;
-	} catch {
-		// Try partial-json for incomplete JSON
-		try {
-			const result = partialParse(partialJson);
-			return (result ?? {}) as T;
-		} catch {
-			// If all parsing fails, return empty object
-			return {} as T;
-		}
-	}
-}

package/src/utils/overflow.ts

@@ -1,121 +0,0 @@
-import type { Message } from "../message/message";
-
-/**
- * Regex patterns to detect context overflow errors from different providers.
- *
- * These patterns match error messages returned when the input exceeds
- * the model's context window.
- *
- * Provider-specific patterns (with example error messages):
- *
- * - Anthropic: "prompt is too long: 213462 tokens > 200000 maximum"
- * - OpenAI: "Your input exceeds the context window of this model"
- * - Google: "The input token count (1196265) exceeds the maximum number of tokens allowed (1048575)"
- * - xAI: "This model's maximum prompt length is 131072 but the request contains 537812 tokens"
- * - Groq: "Please reduce the length of the messages or completion"
- * - OpenRouter: "This endpoint's maximum context length is X tokens. However, you requested about Y tokens"
- * - llama.cpp: "the request exceeds the available context size, try increasing it"
- * - LM Studio: "tokens to keep from the initial prompt is greater than the context length"
- * - GitHub Copilot: "prompt token count of X exceeds the limit of Y"
- * - MiniMax: "invalid params, context window exceeds limit"
- * - Kimi For Coding: "Your request exceeded model token limit: X (requested: Y)"
- * - Cerebras: Returns "400/413 status code (no body)" - handled separately below
- * - Mistral: Returns "400/413 status code (no body)" - handled separately below
- * - z.ai: Does NOT error, accepts overflow silently - handled via usage.input > contextWindow
- * - Ollama: Silently truncates input - not detectable via error message
- */
-const OVERFLOW_PATTERNS = [
-	/prompt is too long/i, // Anthropic
-	/input is too long for requested model/i, // Amazon Bedrock
-	/exceeds the context window/i, // OpenAI (Completions & Responses API)
-	/input token count.*exceeds the maximum/i, // Google (Gemini)
-	/maximum prompt length is \d+/i, // xAI (Grok)
-	/reduce the length of the messages/i, // Groq
-	/maximum context length is \d+ tokens/i, // OpenRouter (all backends)
-	/exceeds the limit of \d+/i, // GitHub Copilot
-	/exceeds the available context size/i, // llama.cpp server
-	/greater than the context length/i, // LM Studio
-	/context window exceeds limit/i, // MiniMax
-	/exceeded model token limit/i, // Kimi For Coding
-	/context[_ ]length[_ ]exceeded/i, // Generic fallback
-	/too many tokens/i, // Generic fallback
-	/token limit exceeded/i, // Generic fallback
-];
-
-/**
- * Check if an assistant message represents a context overflow error.
- *
- * This handles two cases:
- * 1. Error-based overflow: Most providers return stopReason "error" with a
- *    specific error message pattern.
- * 2. Silent overflow: Some providers accept overflow requests and return
- *    successfully. For these, we check if usage.input exceeds the context window.
- *
- * ## Reliability by Provider
- *
- * **Reliable detection (returns error with detectable message):**
- * - Anthropic: "prompt is too long: X tokens > Y maximum"
- * - OpenAI (Completions & Responses): "exceeds the context window"
- * - Google Gemini: "input token count exceeds the maximum"
- * - xAI (Grok): "maximum prompt length is X but request contains Y"
- * - Groq: "reduce the length of the messages"
- * - Cerebras: 400/413 status code (no body)
- * - Mistral: 400/413 status code (no body)
- * - OpenRouter (all backends): "maximum context length is X tokens"
- * - llama.cpp: "exceeds the available context size"
- * - LM Studio: "greater than the context length"
- * - Kimi For Coding: "exceeded model token limit: X (requested: Y)"
- *
- * **Unreliable detection:**
- * - z.ai: Sometimes accepts overflow silently (detectable via usage.input > contextWindow),
- *   sometimes returns rate limit errors. Pass contextWindow param to detect silent overflow.
- * - Ollama: Silently truncates input without error. Cannot be detected via this function.
- *   The response will have usage.input < expected, but we don't know the expected value.
- *
- * ## Custom Providers
- *
- * If you've added custom models via settings.json, this function may not detect
- * overflow errors from those providers. To add support:
- *
- * 1. Send a request that exceeds the model's context window
- * 2. Check the errorMessage in the response
- * 3. Create a regex pattern that matches the error
- * 4. The pattern should be added to OVERFLOW_PATTERNS in this file, or
- *    check the errorMessage yourself before calling this function
- *
- * @param message - The assistant message to check
- * @param contextWindow - Optional context window size for detecting silent overflow (z.ai)
- * @returns true if the message indicates a context overflow
- */
-export function isContextOverflow(message: Message.AssistantMessage, contextWindow?: number): boolean {
-	// Case 1: Check error message patterns
-	if (message.stopReason === "error" && message.errorMessage) {
-		// Check known patterns
-		if (OVERFLOW_PATTERNS.some((p) => p.test(message.errorMessage!))) {
-			return true;
-		}
-
-		// Cerebras and Mistral return 400/413 with no body for context overflow
-		// Note: 429 is rate limiting (requests/tokens per time), NOT context overflow
-		if (/^4(00|13)\s*(status code)?\s*\(no body\)/i.test(message.errorMessage)) {
-			return true;
-		}
-	}
-
-	// Case 2: Silent overflow (z.ai style) - successful but usage exceeds context
-	if (contextWindow && message.stopReason === "stop") {
-		const inputTokens = message.usage.input + message.usage.cacheRead;
-		if (inputTokens > contextWindow) {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/**
- * Get the overflow patterns for testing purposes.
- */
-export function getOverflowPatterns(): RegExp[] {
-	return [...OVERFLOW_PATTERNS];
-}

package/src/utils/sanitize.ts

@@ -1,25 +0,0 @@
-/**
- * Removes unpaired Unicode surrogate characters from a string.
- *
- * Unpaired surrogates (high surrogates 0xD800-0xDBFF without matching low surrogates 0xDC00-0xDFFF,
- * or vice versa) cause JSON serialization errors in many API providers.
- *
- * Valid emoji and other characters outside the Basic Multilingual Plane use properly paired
- * surrogates and will NOT be affected by this function.
- *
- * @param text - The text to sanitize
- * @returns The sanitized text with unpaired surrogates removed
- *
- * @example
- * // Valid emoji (properly paired surrogates) are preserved
- * sanitizeSurrogates("Hello 🙈 World") // => "Hello 🙈 World"
- *
- * // Unpaired high surrogate is removed
- * const unpaired = String.fromCharCode(0xD83D); // high surrogate without low
- * sanitizeSurrogates(`Text ${unpaired} here`) // => "Text  here"
- */
-export function sanitizeSurrogates(text: string): string {
-	// Replace unpaired high surrogates (0xD800-0xDBFF not followed by low surrogate)
-	// Replace unpaired low surrogates (0xDC00-0xDFFF not preceded by high surrogate)
-	return text.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "");
-}