Something went wrong. Try again.
opencode v2 mirror
Something went wrong. Try again.
TypeScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300import { Effect } from "effect"import { constructor, fn, type Impl, type Method, methods } from "../interpreter/native.js"import { checkArrayLength, checkStringLength } from "../interpreter/limits.js"import { invalidData, IteratorSymbol, rangeError, typeError } from "../interpreter/model.js"import { define, get, hidden, Arr, hostIterator, Obj, RegExpObj, record, coerceToInteger, coerceToNumber, coerceToString, type Value,} from "../interpreter/objects.js"import { containsOpaqueReference, typeofValue } from "../interpreter/references.js"import { applyCollectionCallback, isSupportedCallback, toPrimitiveString } from "../interpreter/callback.js"import type { Interpreter } from "../interpreter/interpreter.js"import { matchToValue, toHostRegex } from "./regexp.js"import { coercion } from "./value.js"
// console is intercepted by the interpreter before reaching here.const requireDataArgument = (name: string, index: number, arg: Value): Value => { if (containsOpaqueReference(arg)) { throw invalidData(`String.${name} expects argument ${index + 1} to be a data value.`) } return arg}
const replaceAllNeedsGlobal = (pattern: RegExp) => { if (!pattern.global) { throw typeError( `String.replaceAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.replace to replace only the first match.`, ) }}
const replaceWithCallback = <R>( ctx: Interpreter<R>, value: string, name: "replace" | "replaceAll", args: Array<Value>,): Effect.Effect<Value, unknown, R> => { const builtins = ctx.builtins const apply = applyCollectionCallback(ctx, args[1], `String.${name}`) const matches: Array<{ readonly match: string; readonly offset: number; readonly args: Array<Value> }> = [] // The host calls back with (match, ...captures, offset, string, groups?); only groups is not already a Value. const collect = ( ...callbackArgs: Array<string | number | undefined | Record<string, string | undefined>> ): string => { const match = callbackArgs[0] const hasGroups = typeof callbackArgs.at(-1) === "object" const offset = callbackArgs[callbackArgs.length - (hasGroups ? 3 : 2)] if (typeof match !== "string" || typeof offset !== "number") { throw typeError(`String.${name} produced an invalid replacement match.`) } const args = callbackArgs.map((arg) => (typeof arg === "object" ? record(builtins.Object, arg) : arg)) matches.push({ match, offset, args }) return match }
const pattern = args[0] if (pattern instanceof RegExpObj) { if (name === "replaceAll") replaceAllNeedsGlobal(pattern.regex) if (name === "replace") value.replace(pattern.regex, collect) else value.replaceAll(pattern.regex, collect) } else { const search = coerceToString(requireDataArgument(name, 0, pattern)) if (name === "replace") value.replace(search, collect) else value.replaceAll(search, collect) }
return Effect.gen(function* () { const output: Array<string> = [] let end = 0 for (const match of matches) { const replacement = yield* apply(match.args) output.push(value.slice(end, match.offset), coerceToString(replacement)) end = match.offset + match.match.length } output.push(value.slice(end)) return output.join("") })}
export const stringGlobal = <R>(ctx: Interpreter<R>) => { const builtins = ctx.builtins const string = constructor<R>(builtins, builtins.String, { name: "String", length: 1, call: coercion(ctx, "String").call, }) const codeUnits = (name: string, op: (...codes: Array<number>) => string): Method => [ name, 1, (_, args) => op(...args.map(coerceToNumber)), ] methods(builtins, string, [ codeUnits("fromCharCode", String.fromCharCode), codeUnits("fromCodePoint", String.fromCodePoint), [ "raw", 1, (_, args) => { const template = args[0] const raw = template instanceof Obj ? get(template, "raw") : undefined if (!(raw instanceof Obj)) throw typeError("String.raw expects a template object with a raw array.") const count = Math.max(0, coerceToInteger(get(raw, "length"))) checkArrayLength(count) // Each literal is followed by its substitution, except the last literal, or when substitutions run out. const parts = Array.from({ length: count }, (_, index) => index + 1 < count && index + 1 < args.length ? [get(raw, index), args[index + 1]] : [get(raw, index)], ).flat() return Effect.map( Effect.forEach(parts, (part) => toPrimitiveString(ctx, part)), (strings) => { const output = strings.join("") checkStringLength(output.length) return output }, ) }, ], ])
const self = (thisValue: Value, name: string): string => { if (typeof thisValue === "string") return thisValue if (thisValue === null || thisValue === undefined) { throw typeError(`String.prototype.${name} called on null or undefined.`) } return coerceToString(thisValue) } // Coerce arguments like native JS; opaque runtime references still reject. const str = (name: string, args: Array<Value>, index: number): string => coerceToString(requireDataArgument(name, index, args[index])) const num = (name: string, args: Array<Value>, index: number): number => coerceToNumber(requireDataArgument(name, index, args[index])) const optNum = (name: string, args: Array<Value>, index: number): number | undefined => args[index] === undefined ? undefined : num(name, args, index) const optStr = (name: string, args: Array<Value>, index: number): string | undefined => args[index] === undefined ? undefined : str(name, args, index) const rejectRegex = (name: string, args: Array<Value>): void => { if (args[0] instanceof RegExpObj) { throw typeError( `String.${name} cannot take a regular expression; use regex.test(string) or String.search instead.`, ) } } const simple = ( name: string, length: number, op: (value: string, args: Array<Value>) => ReturnType<Impl>, ): Method => [name, length, (thisValue, args) => op(self(thisValue, name), args)] const replace = (name: "replace" | "replaceAll") => simple(name, 2, (value, args) => { if (isSupportedCallback(args[1])) return replaceWithCallback(ctx, value, name, args) if (typeofValue(args[1]) === "function") { throw typeError( `String.${name} cannot use this callable as a replacer; wrap it in an arrow function, e.g. (match) => tools.ns.tool(match).`, ) } if (args[0] instanceof RegExpObj) { const pattern = args[0].regex const replacement = str(name, args, 1) if (name === "replaceAll") replaceAllNeedsGlobal(pattern) return name === "replace" ? value.replace(pattern, replacement) : value.replaceAll(pattern, replacement) } if (name === "replace") return value.replace(str(name, args, 0), str(name, args, 1)) return value.replaceAll(str(name, args, 0), str(name, args, 1)) })
methods(builtins, builtins.String, [ simple("toString", 0, (value) => value), simple("valueOf", 0, (value) => value), simple("toLowerCase", 0, (value) => value.toLowerCase()), simple("toUpperCase", 0, (value) => value.toUpperCase()), simple("toLocaleLowerCase", 0, (value) => value.toLowerCase()), simple("toLocaleUpperCase", 0, (value) => value.toUpperCase()), simple("trim", 0, (value) => value.trim()), simple("trimStart", 0, (value) => value.trimStart()), simple("trimLeft", 0, (value) => value.trimStart()), simple("trimEnd", 0, (value) => value.trimEnd()), simple("trimRight", 0, (value) => value.trimEnd()), // Locale/options are deliberately unsupported; comparison uses the host default locale. simple("localeCompare", 1, (value, args) => value.localeCompare(str("localeCompare", args, 0))), simple("normalize", 0, (value, args) => { const form = optStr("normalize", args, 0) try { return value.normalize(form) } catch { throw rangeError( `String.normalize expects the form "NFC", "NFD", "NFKC", or "NFKD" (got ${JSON.stringify(form)}).`, ) } }), simple("split", 2, (value, args) => { const wrap = (parts: Array<string>) => new Arr(builtins.Array, parts) // Native: an undefined separator returns the whole string, not a split on "undefined", // unless the limit truncates to zero. const requestedLimit = optNum("split", args, 1) if (args[0] === undefined) { return wrap(requestedLimit !== undefined && requestedLimit >>> 0 === 0 ? [] : [value]) } const parts = args[0] instanceof RegExpObj ? value.split(args[0].regex, requestedLimit) : value.split(str("split", args, 0), requestedLimit === undefined ? undefined : requestedLimit >>> 0) checkArrayLength(parts.length) return wrap(parts) }), simple("slice", 2, (value, args) => value.slice(optNum("slice", args, 0), optNum("slice", args, 1))), simple("includes", 1, (value, args) => { rejectRegex("includes", args) return value.includes(str("includes", args, 0), optNum("includes", args, 1)) }), simple("startsWith", 1, (value, args) => { rejectRegex("startsWith", args) return value.startsWith(str("startsWith", args, 0), optNum("startsWith", args, 1)) }), simple("endsWith", 1, (value, args) => { rejectRegex("endsWith", args) return value.endsWith(str("endsWith", args, 0), optNum("endsWith", args, 1)) }), simple("indexOf", 1, (value, args) => value.indexOf(str("indexOf", args, 0), optNum("indexOf", args, 1))), simple("lastIndexOf", 1, (value, args) => value.lastIndexOf(str("lastIndexOf", args, 0), optNum("lastIndexOf", args, 1)), ), replace("replace"), replace("replaceAll"), simple("match", 1, (value, args) => { const pattern = toHostRegex(args[0], "match") const matched = value.match(pattern) if (matched === null) return null // Preserve the own `index` and `groups` properties on non-global matches. if (pattern.global) return new Arr(builtins.Array, [...matched]) return matchToValue(builtins, matched) }), simple("matchAll", 1, (value, args) => { const pattern = toHostRegex(args[0], "matchAll", "g") if (!pattern.global) { throw typeError( `String.matchAll requires a regular expression with the global (g) flag: write /${pattern.source}/${pattern.flags}g, or use String.match for a single match.`, ) } const matches: Array<Value> = [] for (const match of value.matchAll(pattern)) { checkArrayLength(matches.length + 1) matches.push(matchToValue(builtins, match)) } return new Arr(builtins.Array, matches) }), simple("search", 1, (value, args) => value.search(toHostRegex(args[0], "search"))), simple("repeat", 1, (value, args) => { const count = num("repeat", args, 0) if (!Number.isFinite(count) || count < 0) { throw rangeError("String.repeat expects a finite non-negative count.") } checkStringLength(value.length * count) return value.repeat(count) }), simple("padStart", 1, (value, args) => { const length = num("padStart", args, 0) checkStringLength(length) return value.padStart(length, optStr("padStart", args, 1)) }), simple("padEnd", 1, (value, args) => { const length = num("padEnd", args, 0) checkStringLength(length) return value.padEnd(length, optStr("padEnd", args, 1)) }), simple("charAt", 1, (value, args) => value.charAt(optNum("charAt", args, 0) ?? 0)), simple("at", 1, (value, args) => value.at(optNum("at", args, 0) ?? 0)), simple("substring", 2, (value, args) => value.substring(optNum("substring", args, 0) ?? 0, optNum("substring", args, 1)), ), simple("substr", 2, (value, args) => value.substr(optNum("substr", args, 0) ?? 0, optNum("substr", args, 1))), simple("isWellFormed", 0, (value) => value.isWellFormed()), simple("toWellFormed", 0, (value) => value.toWellFormed()), simple("charCodeAt", 1, (value, args) => value.charCodeAt(optNum("charCodeAt", args, 0) ?? 0)), simple("codePointAt", 1, (value, args) => value.codePointAt(optNum("codePointAt", args, 0) ?? 0)), simple("concat", 1, (value, args) => { const joined = value.concat(...args.map((_, index) => str("concat", args, index))) checkStringLength(joined.length) return joined }), ]) define( builtins.String, IteratorSymbol, fn(builtins, "[Symbol.iterator]", 0, (thisValue) => hostIterator(builtins, self(thisValue, "[Symbol.iterator]")[Symbol.iterator]()), ), hidden, ) return string}