Versions in this module Expand all Collapse all v0 v0.1.1 Nov 15, 2026 v0.1.0 Nov 9, 2026 Changes in this version + const CompareFalse + const CompareTrue + const CompareUndefined + const DefaultMaxDynamicSource + const MaxCallDepth + const MaxStringLength + const MaxToGoDepth + var AtomAbs = staticAtom("abs") + var AtomAcos = staticAtom("acos") + var AtomAcosh = staticAtom("acosh") + var AtomAdd = staticAtom("add") + var AtomAggregateError = staticAtom("AggregateError") + var AtomAll = staticAtom("all") + var AtomAllSettled = staticAtom("allSettled") + var AtomAnchor = staticAtom("anchor") + var AtomAnonymous = staticAtom("anonymous") + var AtomAny = staticAtom("any") + var AtomApply = staticAtom("apply") + var AtomArguments = staticAtom("arguments") + var AtomArray = staticAtom("Array") + var AtomArrayBuffer = staticAtom("ArrayBuffer") + var AtomArrayIterator = staticAtom("Array Iterator") + var AtomAsIntN = staticAtom("asIntN") + var AtomAsUintN = staticAtom("asUintN") + var AtomAsin = staticAtom("asin") + var AtomAsinh = staticAtom("asinh") + var AtomAssign = staticAtom("assign") + var AtomAsyncFunction = staticAtom("AsyncFunction") + var AtomAsyncGenerator = staticAtom("AsyncGenerator") + var AtomAsyncGeneratorFunction = staticAtom("AsyncGeneratorFunction") + var AtomAsyncIterator = staticAtom("asyncIterator") + var AtomAt = staticAtom("at") + var AtomAtan = staticAtom("atan") + var AtomAtan2 = staticAtom("atan2") + var AtomAtanh = staticAtom("atanh") + var AtomAtob = staticAtom("atob") + var AtomAtomics = staticAtom("Atomics") + var AtomBig = staticAtom("big") + var AtomBigInt = staticAtom("BigInt") + var AtomBigInt64Array = staticAtom("BigInt64Array") + var AtomBigUint64Array = staticAtom("BigUint64Array") + var AtomBind = staticAtom("bind") + var AtomBlink = staticAtom("blink") + var AtomBold = staticAtom("bold") + var AtomBoolean = staticAtom("Boolean") + var AtomBoundSpace = staticAtom("bound ") + var AtomBtoa = staticAtom("btoa") + var AtomCall = staticAtom("call") + var AtomCallee = staticAtom("callee") + var AtomCaller = staticAtom("caller") + var AtomCaptureStackTrace = staticAtom("captureStackTrace") + var AtomCatch = staticAtom("catch") + var AtomCause = staticAtom("cause") + var AtomCbrt = staticAtom("cbrt") + var AtomCeil = staticAtom("ceil") + var AtomCharAt = staticAtom("charAt") + var AtomCharCodeAt = staticAtom("charCodeAt") + var AtomClear = staticAtom("clear") + var AtomClz32 = staticAtom("clz32") + var AtomCode = staticAtom("code") + var AtomCodePointAt = staticAtom("codePointAt") + var AtomCompile = staticAtom("compile") + var AtomConcat = staticAtom("concat") + var AtomConfigurable = staticAtom("configurable") + var AtomConstruct = staticAtom("construct") + var AtomConstructor = staticAtom("constructor") + var AtomCopyWithin = staticAtom("copyWithin") + var AtomCos = staticAtom("cos") + var AtomCosh = staticAtom("cosh") + var AtomCreate = staticAtom("create") + var AtomDataView = staticAtom("DataView") + var AtomDate = staticAtom("Date") + var AtomDecodeURI = staticAtom("decodeURI") + var AtomDecodeURIComponent = staticAtom("decodeURIComponent") + var AtomDefault = staticAtom("default") + var AtomDefineGetter = staticAtom("__defineGetter__") + var AtomDefineProperties = staticAtom("defineProperties") + var AtomDefineProperty = staticAtom("defineProperty") + var AtomDefineSetter = staticAtom("__defineSetter__") + var AtomDelete = staticAtom("delete") + var AtomDeleteProperty = staticAtom("deleteProperty") + var AtomDeref = staticAtom("deref") + var AtomDescription = staticAtom("description") + var AtomDifference = staticAtom("difference") + var AtomDone = staticAtom("done") + var AtomDotAll = staticAtom("dotAll") + var AtomDunderProto = staticAtom("__proto__") + var AtomDuration = staticAtom("duration") + var AtomE = staticAtom("E") + var AtomEPSILON = staticAtom("EPSILON") + var AtomEmpty = staticAtom("") + var AtomEncodeURI = staticAtom("encodeURI") + var AtomEncodeURIComponent = staticAtom("encodeURIComponent") + var AtomEndsWith = staticAtom("endsWith") + var AtomEntries = staticAtom("entries") + var AtomEnumerable = staticAtom("enumerable") + var AtomError = staticAtom("Error") + var AtomErrors = staticAtom("errors") + var AtomEscape = staticAtom("escape") + var AtomEval = staticAtom("eval") + var AtomEvalError = staticAtom("EvalError") + var AtomEvery = staticAtom("every") + var AtomExec = staticAtom("exec") + var AtomExp = staticAtom("exp") + var AtomExpm1 = staticAtom("expm1") + var AtomF16round = staticAtom("f16round") + var AtomFalse = staticAtom("false") + var AtomFill = staticAtom("fill") + var AtomFilter = staticAtom("filter") + var AtomFinally = staticAtom("finally") + var AtomFind = staticAtom("find") + var AtomFindIndex = staticAtom("findIndex") + var AtomFindLast = staticAtom("findLast") + var AtomFindLastIndex = staticAtom("findLastIndex") + var AtomFixed = staticAtom("fixed") + var AtomFlags = staticAtom("flags") + var AtomFlat = staticAtom("flat") + var AtomFlatMap = staticAtom("flatMap") + var AtomFloat16Array = staticAtom("Float16Array") + var AtomFloat32Array = staticAtom("Float32Array") + var AtomFloat64Array = staticAtom("Float64Array") + var AtomFloor = staticAtom("floor") + var AtomFontcolor = staticAtom("fontcolor") + var AtomFontsize = staticAtom("fontsize") + var AtomFor = staticAtom("for") + var AtomForEach = staticAtom("forEach") + var AtomFreeze = staticAtom("freeze") + var AtomFrom = staticAtom("from") + var AtomFromAsync = staticAtom("fromAsync") + var AtomFromCharCode = staticAtom("fromCharCode") + var AtomFromCodePoint = staticAtom("fromCodePoint") + var AtomFromEntries = staticAtom("fromEntries") + var AtomFround = staticAtom("fround") + var AtomFunction = staticAtom("Function") + var AtomGenerator = staticAtom("Generator") + var AtomGeneratorFunction = staticAtom("GeneratorFunction") + var AtomGet = staticAtom("get") + var AtomGetFullYear = staticAtom("getFullYear") + var AtomGetOwnPropertyDescriptor = staticAtom("getOwnPropertyDescriptor") + var AtomGetOwnPropertyDescriptors = staticAtom("getOwnPropertyDescriptors") + var AtomGetOwnPropertyNames = staticAtom("getOwnPropertyNames") + var AtomGetOwnPropertySymbols = staticAtom("getOwnPropertySymbols") + var AtomGetPrototypeOf = staticAtom("getPrototypeOf") + var AtomGetTime = staticAtom("getTime") + var AtomGlobal = staticAtom("global") + var AtomGlobalThis = staticAtom("globalThis") + var AtomGroupBy = staticAtom("groupBy") + var AtomGroups = staticAtom("groups") + var AtomHas = staticAtom("has") + var AtomHasIndices = staticAtom("hasIndices") + var AtomHasInstance = staticAtom("hasInstance") + var AtomHasOwn = staticAtom("hasOwn") + var AtomHasOwnProperty = staticAtom("hasOwnProperty") + var AtomHypot = staticAtom("hypot") + var AtomIgnoreCase = staticAtom("ignoreCase") + var AtomImul = staticAtom("imul") + var AtomIncludes = staticAtom("includes") + var AtomIndex = staticAtom("index") + var AtomIndexOf = staticAtom("indexOf") + var AtomIndices = staticAtom("indices") + var AtomInfinity = staticAtom("Infinity") + var AtomInput = staticAtom("input") + var AtomInt16Array = staticAtom("Int16Array") + var AtomInt32Array = staticAtom("Int32Array") + var AtomInt8Array = staticAtom("Int8Array") + var AtomInternalError = staticAtom("InternalError") + var AtomIntersection = staticAtom("intersection") + var AtomIntl = staticAtom("Intl") + var AtomInvalidCharacterError = staticAtom("InvalidCharacterError") + var AtomIs = staticAtom("is") + var AtomIsArray = staticAtom("isArray") + var AtomIsConcatSpreadable = staticAtom("isConcatSpreadable") + var AtomIsDisjointFrom = staticAtom("isDisjointFrom") + var AtomIsError = staticAtom("isError") + var AtomIsExtensible = staticAtom("isExtensible") + var AtomIsFinite = staticAtom("isFinite") + var AtomIsFrozen = staticAtom("isFrozen") + var AtomIsInteger = staticAtom("isInteger") + var AtomIsNaN = staticAtom("isNaN") + var AtomIsPrototypeOf = staticAtom("isPrototypeOf") + var AtomIsSafeInteger = staticAtom("isSafeInteger") + var AtomIsSealed = staticAtom("isSealed") + var AtomIsSubsetOf = staticAtom("isSubsetOf") + var AtomIsSupersetOf = staticAtom("isSupersetOf") + var AtomIsWellFormed = staticAtom("isWellFormed") + var AtomItalics = staticAtom("italics") + var AtomIterator = staticAtom("iterator") + var AtomJSON = staticAtom("JSON") + var AtomJoin = staticAtom("join") + var AtomKeyFor = staticAtom("keyFor") + var AtomKeys = staticAtom("keys") + var AtomLN10 = staticAtom("LN10") + var AtomLN2 = staticAtom("LN2") + var AtomLOG10E = staticAtom("LOG10E") + var AtomLOG2E = staticAtom("LOG2E") + var AtomLastIndex = staticAtom("lastIndex") + var AtomLastIndexOf = staticAtom("lastIndexOf") + var AtomLength = staticAtom("length") + var AtomLink = staticAtom("link") + var AtomLocaleCompare = staticAtom("localeCompare") + var AtomLog = staticAtom("log") + var AtomLog10 = staticAtom("log10") + var AtomLog1p = staticAtom("log1p") + var AtomLog2 = staticAtom("log2") + var AtomLookupGetter = staticAtom("__lookupGetter__") + var AtomLookupSetter = staticAtom("__lookupSetter__") + var AtomMap = staticAtom("map") + var AtomMapIterator = staticAtom("Map Iterator") + var AtomMapName = staticAtom("Map") + var AtomMatch = staticAtom("match") + var AtomMatchAll = staticAtom("matchAll") + var AtomMath = staticAtom("Math") + var AtomMax = staticAtom("max") + var AtomMaxSafeInteger = staticAtom("MAX_SAFE_INTEGER") + var AtomMaxValue = staticAtom("MAX_VALUE") + var AtomMessage = staticAtom("message") + var AtomMin = staticAtom("min") + var AtomMinSafeInteger = staticAtom("MIN_SAFE_INTEGER") + var AtomMinValue = staticAtom("MIN_VALUE") + var AtomModel = staticAtom("model") + var AtomMultiline = staticAtom("multiline") + var AtomNaN = staticAtom("NaN") + var AtomName = staticAtom("name") + var AtomNegInfinity = staticAtom("-Infinity") + var AtomNegativeInfinity = staticAtom("NEGATIVE_INFINITY") + var AtomNext = staticAtom("next") + var AtomNormalize = staticAtom("normalize") + var AtomNow = staticAtom("now") + var AtomNull = staticAtom("null") + var AtomNumber = staticAtom("Number") + var AtomObject = staticAtom("Object") + var AtomOf = staticAtom("of") + var AtomOwnKeys = staticAtom("ownKeys") + var AtomPI = staticAtom("PI") + var AtomPadEnd = staticAtom("padEnd") + var AtomPadStart = staticAtom("padStart") + var AtomParse = staticAtom("parse") + var AtomParseFloat = staticAtom("parseFloat") + var AtomParseInt = staticAtom("parseInt") + var AtomPop = staticAtom("pop") + var AtomPositiveInfinity = staticAtom("POSITIVE_INFINITY") + var AtomPow = staticAtom("pow") + var AtomPreventExtensions = staticAtom("preventExtensions") + var AtomPromise = staticAtom("Promise") + var AtomPrompt = staticAtom("prompt") + var AtomPropertyIsEnumerable = staticAtom("propertyIsEnumerable") + var AtomPrototype = staticAtom("prototype") + var AtomProxy = staticAtom("Proxy") + var AtomProxyLower = staticAtom("proxy") + var AtomPush = staticAtom("push") + var AtomQueueMicrotask = staticAtom("queueMicrotask") + var AtomRace = staticAtom("race") + var AtomRandom = staticAtom("random") + var AtomRangeError = staticAtom("RangeError") + var AtomRaw = staticAtom("raw") + var AtomReduce = staticAtom("reduce") + var AtomReduceRight = staticAtom("reduceRight") + var AtomReferenceError = staticAtom("ReferenceError") + var AtomReflect = staticAtom("Reflect") + var AtomRegExp = staticAtom("RegExp") + var AtomRegExpStringIterator = staticAtom("RegExp String Iterator") + var AtomReject = staticAtom("reject") + var AtomRepeat = staticAtom("repeat") + var AtomReplace = staticAtom("replace") + var AtomReplaceAll = staticAtom("replaceAll") + var AtomResolve = staticAtom("resolve") + var AtomReturn = staticAtom("return") + var AtomReverse = staticAtom("reverse") + var AtomRevocable = staticAtom("revocable") + var AtomRevoke = staticAtom("revoke") + var AtomRound = staticAtom("round") + var AtomSQRT2 = staticAtom("SQRT2") + var AtomSeal = staticAtom("seal") + var AtomSearch = staticAtom("search") + var AtomSeed = staticAtom("seed") + var AtomSet = staticAtom("set") + var AtomSetIterator = staticAtom("Set Iterator") + var AtomSetName = staticAtom("Set") + var AtomSetPrototypeOf = staticAtom("setPrototypeOf") + var AtomSharedArrayBuffer = staticAtom("SharedArrayBuffer") + var AtomShift = staticAtom("shift") + var AtomSign = staticAtom("sign") + var AtomSin = staticAtom("sin") + var AtomSinh = staticAtom("sinh") + var AtomSize = staticAtom("size") + var AtomSlice = staticAtom("slice") + var AtomSmall = staticAtom("small") + var AtomSome = staticAtom("some") + var AtomSort = staticAtom("sort") + var AtomSource = staticAtom("source") + var AtomSpecies = staticAtom("species") + var AtomSplice = staticAtom("splice") + var AtomSplit = staticAtom("split") + var AtomSqrt = staticAtom("sqrt") + var AtomSqrt12 = staticAtom("SQRT1_2") + var AtomStack = staticAtom("stack") + var AtomStackTraceLimit = staticAtom("stackTraceLimit") + var AtomStartsWith = staticAtom("startsWith") + var AtomSticky = staticAtom("sticky") + var AtomStrike = staticAtom("strike") + var AtomString = staticAtom("String") + var AtomStringIterator = staticAtom("String Iterator") + var AtomStringify = staticAtom("stringify") + var AtomStructuredClone = staticAtom("structuredClone") + var AtomSub = staticAtom("sub") + var AtomSubstr = staticAtom("substr") + var AtomSubstring = staticAtom("substring") + var AtomSumPrecise = staticAtom("sumPrecise") + var AtomSup = staticAtom("sup") + var AtomSymbol = staticAtom("Symbol") + var AtomSymmetricDifference = staticAtom("symmetricDifference") + var AtomSyntaxError = staticAtom("SyntaxError") + var AtomTan = staticAtom("tan") + var AtomTanh = staticAtom("tanh") + var AtomTest = staticAtom("test") + var AtomTextDecoder = staticAtom("TextDecoder") + var AtomTextEncoder = staticAtom("TextEncoder") + var AtomThen = staticAtom("then") + var AtomThrow = staticAtom("throw") + var AtomToDateString = staticAtom("toDateString") + var AtomToExponential = staticAtom("toExponential") + var AtomToFixed = staticAtom("toFixed") + var AtomToISOString = staticAtom("toISOString") + var AtomToJSON = staticAtom("toJSON") + var AtomToLocaleLowerCase = staticAtom("toLocaleLowerCase") + var AtomToLocaleString = staticAtom("toLocaleString") + var AtomToLocaleUpperCase = staticAtom("toLocaleUpperCase") + var AtomToLowerCase = staticAtom("toLowerCase") + var AtomToPrecision = staticAtom("toPrecision") + var AtomToPrimitive = staticAtom("toPrimitive") + var AtomToReversed = staticAtom("toReversed") + var AtomToSorted = staticAtom("toSorted") + var AtomToSpliced = staticAtom("toSpliced") + var AtomToString = staticAtom("toString") + var AtomToStringTag = staticAtom("toStringTag") + var AtomToUTCString = staticAtom("toUTCString") + var AtomToUpperCase = staticAtom("toUpperCase") + var AtomToWellFormed = staticAtom("toWellFormed") + var AtomTrim = staticAtom("trim") + var AtomTrimEnd = staticAtom("trimEnd") + var AtomTrimLeft = staticAtom("trimLeft") + var AtomTrimRight = staticAtom("trimRight") + var AtomTrimStart = staticAtom("trimStart") + var AtomTrue = staticAtom("true") + var AtomTrunc = staticAtom("trunc") + var AtomTry = staticAtom("try") + var AtomTypeBigint = staticAtom("bigint") + var AtomTypeBoolean = staticAtom("boolean") + var AtomTypeError = staticAtom("TypeError") + var AtomTypeFunction = staticAtom("function") + var AtomTypeNumber = staticAtom("number") + var AtomTypeObject = staticAtom("object") + var AtomTypeString = staticAtom("string") + var AtomTypeSymbol = staticAtom("symbol") + var AtomURIError = staticAtom("URIError") + var AtomUint16Array = staticAtom("Uint16Array") + var AtomUint32Array = staticAtom("Uint32Array") + var AtomUint8Array = staticAtom("Uint8Array") + var AtomUint8ClampedArray = staticAtom("Uint8ClampedArray") + var AtomUndefined = staticAtom("undefined") + var AtomUnescape = staticAtom("unescape") + var AtomUnicode = staticAtom("unicode") + var AtomUnicodeSets = staticAtom("unicodeSets") + var AtomUnion = staticAtom("union") + var AtomUnscopables = staticAtom("unscopables") + var AtomUnshift = staticAtom("unshift") + var AtomValue = staticAtom("value") + var AtomValueOf = staticAtom("valueOf") + var AtomValues = staticAtom("values") + var AtomWeakMap = staticAtom("WeakMap") + var AtomWeakRef = staticAtom("WeakRef") + var AtomWeakSet = staticAtom("WeakSet") + var AtomWith = staticAtom("with") + var AtomWithResolvers = staticAtom("withResolvers") + var AtomWritable = staticAtom("writable") + var ErrForeign = errors.New("moejs: function or generator of another runtime") + var ErrFromGoDepth = errors.New("engine: FromGo value nesting exceeds depth limit") + var ErrMemoryLimit = errors.New("memory limit exceeded") + var ErrModulePending = errors.New("engine: module evaluation is still pending after the job queue drained") + var ErrNoInterpreter = errors.New("engine: bytecode interpreter is not linked") + var ErrNoResolver = errors.New("no resolver: the host must resolve the module's requests") + var ErrTooDeep = errors.New("nesting is too deep") + var ErrTooLarge = errors.New("moejs: decoded value too large") + var SymAsyncIterator = wellKnownSymbol(staticAtom("Symbol.asyncIterator")) + var SymHasInstance = wellKnownSymbol(staticAtom("Symbol.hasInstance")) + var SymIsConcatSpreadable = wellKnownSymbol(staticAtom("Symbol.isConcatSpreadable")) + var SymIterator = wellKnownSymbol(staticAtom("Symbol.iterator")) + var SymMatch = wellKnownSymbol(staticAtom("Symbol.match")) + var SymMatchAll = wellKnownSymbol(staticAtom("Symbol.matchAll")) + var SymReplace = wellKnownSymbol(staticAtom("Symbol.replace")) + var SymSearch = wellKnownSymbol(staticAtom("Symbol.search")) + var SymSpecies = wellKnownSymbol(staticAtom("Symbol.species")) + var SymSplit = wellKnownSymbol(staticAtom("Symbol.split")) + var SymToPrimitive = wellKnownSymbol(staticAtom("Symbol.toPrimitive")) + var SymToStringTag = wellKnownSymbol(staticAtom("Symbol.toStringTag")) + var SymUnscopables = wellKnownSymbol(staticAtom("Symbol.unscopables")) + func AppendNumber(dst []byte, f float64) []byte + func CanonicalNumericIndexString(s *String) (float64, bool) + func FormatStack(r *Realm, frames []StackFrame) string + func IsArray(v Value) bool + func IsCallable(v Value) bool + func IsConstructor(v Value) bool + func MeasureDecodeGo(g any, opts DecodeOptions) error + func MeasureDecodeText(text []byte, opts DecodeOptions) error + func NumberExponentiate(base, exponent float64) float64 + func NumberToGoString(f float64) string + func NumberToStringRadix(value float64, radix int) string + func SameValue(a, b Value) bool + func SameValueZero(a, b Value) bool + func SetCompiler(c Compiler) + func StrictEquals(a, b Value) bool + func StringToNumber(s *String) float64 + func ToBoolean(v Value) bool + func ToInt32Float(f float64) int32 + func ToIntegerOrInfinityFloat(f float64) float64 + func ToUint32Float(f float64) uint32 + func ValidateAndApplyPropertyDescriptor(r *Realm, o *Object, key PropertyKey, extensible bool, desc PropertyDescriptor, ...) bool + type Accessor struct + Get *Object + Set *Object + type BigInt struct + func NewBigIntFromBig(x *big.Int) (*BigInt, bool) + func NewBigIntFromDecimal(text string) (*BigInt, bool) + func NewBigIntFromInt64(i int64) *BigInt + func NewBigIntFromUint64(u uint64) *BigInt + func StringToBigInt(s *String) (*BigInt, bool) + func (b *BigInt) Big() *big.Int + func (b *BigInt) Float64() float64 + func (b *BigInt) Int64() int64 + func (b *BigInt) IsZero() bool + func (b *BigInt) StrictEquals(o *BigInt) bool + func (b *BigInt) ToString() string + func (b *BigInt) Uint64() uint64 + type CallState struct + type Class uint8 + const ClassArguments + const ClassArray + const ClassArrayBuffer + const ClassArrayIterator + const ClassAsyncGenerator + const ClassBigInt + const ClassBoolean + const ClassDataView + const ClassDate + const ClassError + const ClassFunction + const ClassGenerator + const ClassIntlDateTimeFormat + const ClassIntlLocale + const ClassIntlNumberFormat + const ClassIntlPluralRules + const ClassIntlSegmentIterator + const ClassIntlSegmenter + const ClassIntlSegments + const ClassMap + const ClassMapIterator + const ClassNumber + const ClassObject + const ClassPromise + const ClassProxy + const ClassRegExp + const ClassRegExpStringIterator + const ClassSet + const ClassSetIterator + const ClassSharedArrayBuffer + const ClassString + const ClassStringIterator + const ClassSymbol + const ClassTextDecoder + const ClassTextEncoder + const ClassTypedArray + const ClassWeakMap + const ClassWeakRef + const ClassWeakSet + func (c Class) String() string + type Compiler interface + CompileEval func(name, src string, scope *bytecode.EvalScope, stop func() error) (*bytecode.Function, error) + CompileFunction func(name, params, body string, generator, async bool, stop func() error) (*bytecode.Function, error) + CompileScript func(name, src string, stop func() error) (*bytecode.Function, error) + type DateData struct + func (d *DateData) TimeValue() float64 + type DecodeOptions struct + MaxBytes int + MaxNodes int + type Env struct + func NewEnv(parent *Env, n int) *Env + func (e *Env) Len() int + func (e *Env) Parent() *Env + func (e *Env) SetSlot(i int, v Value) + func (e *Env) Slot(i int) Value + func (e *Env) Slots() []Value + type ErrorData struct + func (ed *ErrorData) Frames() []StackFrame + type ErrorKind uint8 + const KindError + const KindEvalError + const KindRangeError + const KindReferenceError + const KindSyntaxError + const KindTypeError + const KindURIError + func (k ErrorKind) Name() *String + type Exception struct + Stack string + Value Value + func (e *Exception) Error() string + func (e *Exception) Message() string + func (e *Exception) Name() string + func (e *Exception) String() string + func (e *Exception) Unwrap() error + type FuncKind uint8 + const FuncBound + const FuncBytecode + const FuncNative + const FuncNativeData + const FuncProxy + type FunctionData struct + func (fd *FunctionData) BoundTarget() *Object + func (fd *FunctionData) Code() *bytecode.Function + func (fd *FunctionData) Data() any + func (fd *FunctionData) Env() *Env + func (fd *FunctionData) HomeObject() *Object + func (fd *FunctionData) IsConstructor() bool + func (fd *FunctionData) Kind() FuncKind + func (fd *FunctionData) Name() *String + func (fd *FunctionData) Native() NativeFunc + func (fd *FunctionData) Realm() *Realm + func (fd *FunctionData) SetHomeObject(o *Object) + func (fd *FunctionData) ThisValue() Value + type Hint uint8 + const HintDefault + const HintNumber + const HintString + type ICEntry struct + Epoch uint32 + Shape *Shape + func (e *ICEntry) Holder(o *Object) *Object + func (e *ICEntry) HolderDepth() uint8 + func (e *ICEntry) HolderNear(o *Object) *Object + func (e *ICEntry) Near() bool + func (e *ICEntry) Slot() uint32 + func (e *ICEntry) Valid(r *Realm, o *Object) bool + type ImportHooks struct + Link func(r *Realm, module any) (*ModuleGraph, error) + Load func(r *Realm, referrer any, specifier string) (module any, err error) + Meta func(r *Realm, module any, meta *Object) error + type InterruptedError struct + Value any + func (e *InterruptedError) Error() string + func (e *InterruptedError) Unwrap() error + type Intrinsics struct + ArrayCtor *Object + ArrayIteratorPrototype *Object + ArrayPrototype *Object + BigIntPrototype *Object + BooleanCtor *Object + BooleanPrototype *Object + DateCtor *Object + DatePrototype *Object + ErrorPrototype *Object + FunctionCtor *Object + FunctionPrototype *Object + JSON *Object + Math *Object + NumberCtor *Object + NumberPrototype *Object + ObjectCtor *Object + ObjectPrototype *Object + RegExpCtor *Object + RegExpPrototype *Object + StringCtor *Object + StringPrototype *Object + type IterKind uint8 + const IterEntries + const IterKeys + const IterValues + type IteratorData struct + Done bool + Index int + Kind IterKind + Target Value + func (d *IteratorData) Next(r *Realm) (Value, bool, error) + type JSONOptions struct + Strict bool + type LinkError struct + Col int + Err error + Line int + Module *bytecode.Function + Msg string + Specifier string + func (e *LinkError) Error() string + func (e *LinkError) Unwrap() error + type LinkOptions struct + EarlyExports func(code *bytecode.Function) (*bytecode.Function, error) + HostDefined func(code *bytecode.Function) any + Resolve func(referrer *bytecode.Function, request int) (*bytecode.Function, error) + type LiveReporter interface + ReportLive func(add func(Value), addBytes func(n int)) + type LossyJSONError struct + Object bool + Omitted bool + Path string + Value string + func (e *LossyJSONError) Error() string + type MemoryLimitError struct + Allocated int64 + Limit int64 + Live int64 + Stack string + func (e *MemoryLimitError) Error() string + func (e *MemoryLimitError) Unwrap() error + type ModuleBinding struct + Module int32 + Slot int32 + type ModuleEnv struct + func NewModuleEnv(nslots int, module *bytecode.Module) *ModuleEnv + func (m *ModuleEnv) ExportNames() []string + func (m *ModuleEnv) GetBindingValue(name string) (Value, bool) + type ModuleGraph struct + func LinkModules(entry *bytecode.Function, opts LinkOptions) (*ModuleGraph, error) + func (g *ModuleGraph) Binding(name string) (ModuleBinding, bool) + func (g *ModuleGraph) Exports() []string + func (g *ModuleGraph) Records() []*bytecode.Function + type NativeCtor func(r *Realm, args []Value, newTarget *Object) (Value, error) + type NativeDataFunc func(r *Realm, fd *FunctionData, this Value, args []Value) (Value, error) + type NativeFunc func(r *Realm, this Value, args []Value) (Value, error) + type Object struct + func (o *Object) ArrayLength() uint32 + func (o *Object) BufferData() (data []byte, ok bool) + func (o *Object) Class() Class + func (o *Object) ClassName() string + func (o *Object) CreateDataProperty(r *Realm, key PropertyKey, v Value) (bool, error) + func (o *Object) CreateDataPropertyOrThrow(r *Realm, key PropertyKey, v Value) error + func (o *Object) DateValue() (float64, bool) + func (o *Object) DefineLazyProperties(r *Realm, keys []PropertyKey, init func(r *Realm, i int) Value) + func (o *Object) DefineLazyProperty(r *Realm, key PropertyKey, init func(*Realm) Value) + func (o *Object) DefineOwnAccessorFast(r *Realm, key PropertyKey, get, set *Object, attrs uint8) + func (o *Object) DefineOwnDataFast(r *Realm, key PropertyKey, v Value, attrs uint8) + func (o *Object) DefineOwnProperty(r *Realm, key PropertyKey, desc PropertyDescriptor) (bool, error) + func (o *Object) DefinePropertyOrThrow(r *Realm, key PropertyKey, desc PropertyDescriptor) error + func (o *Object) Delete(r *Realm, key PropertyKey) bool + func (o *Object) DeletePropertyOrThrow(r *Realm, key PropertyKey) error + func (o *Object) Elements() []Value + func (o *Object) ErrorData() *ErrorData + func (o *Object) Freeze(r *Realm) + func (o *Object) FunctionData() *FunctionData + func (o *Object) Get(r *Realm, key PropertyKey, receiver Value) (Value, error) + func (o *Object) GetIndex(r *Realm, i uint32) (Value, error) + func (o *Object) GetOwnDataValue(key PropertyKey) (Value, bool) + func (o *Object) GetOwnProperty(key PropertyKey) (PropertyDescriptor, bool) + func (o *Object) GetProp(r *Realm, key PropertyKey) (Value, error) + func (o *Object) HasOwnProperty(key PropertyKey) bool + func (o *Object) HasProperty(key PropertyKey) bool + func (o *Object) HoldsCode() bool + func (o *Object) HostValue() (v any, ok bool) + func (o *Object) Internal() (v any) + func (o *Object) IsCallable() bool + func (o *Object) IsDenseArray() bool + func (o *Object) IsDetachedBuffer() bool + func (o *Object) IsDictionaryMode() bool + func (o *Object) IsExtensible() bool + func (o *Object) IsFrozen() bool + func (o *Object) IsModuleNamespace() bool + func (o *Object) IsPrototypeObject() bool + func (o *Object) IsRevokedProxy() bool + func (o *Object) IsSealed() bool + func (o *Object) IsShared() bool + func (o *Object) KeepShape() + func (o *Object) Lookup(r *Realm, key PropertyKey) (v Value, found bool, err error) + func (o *Object) OwnEnumerableStringKeys() []PropertyKey + func (o *Object) OwnPropertyKeys() []PropertyKey + func (o *Object) PreventExtensions(r *Realm) + func (o *Object) PrimitiveValue() (Value, bool) + func (o *Object) PromiseResult() (state PromiseState, result Value, ok bool) + func (o *Object) Proto() *Object + func (o *Object) Push(r *Realm, values ...Value) bool + func (o *Object) RegExpData() *RegExpData + func (o *Object) ReserveSlots(r *Realm, n int) + func (o *Object) Seal(r *Realm) + func (o *Object) Set(r *Realm, key PropertyKey, v Value, receiver Value) (bool, error) + func (o *Object) SetInternal(v any) + func (o *Object) SetLength(r *Realm, n uint32) (bool, error) + func (o *Object) SetProp(r *Realm, key PropertyKey, v Value) error + func (o *Object) SetPrototypeOf(r *Realm, proto *Object) bool + func (o *Object) SetSlot(i uint32, v Value) + func (o *Object) Shape() *Shape + func (o *Object) Slot(i uint32) Value + func (o *Object) TypedArrayElements() (elems any, ok bool) + type ObjectTemplate struct + func (t *ObjectTemplate) Len() int + type PrivateName struct + type PromiseRejectionOperation uint8 + const PromiseRejectionHandle + const PromiseRejectionReject + type PromiseState uint8 + const PromiseFulfilled + const PromisePending + const PromiseRejected + type PropertyDescriptor struct + Get Value + Set Value + Value Value + func AccessorDescriptor(get, set *Object, attrs uint8) PropertyDescriptor + func DataDescriptor(v Value, attrs uint8) PropertyDescriptor + func (d *PropertyDescriptor) SetConfigurable(b bool) + func (d *PropertyDescriptor) SetEnumerable(b bool) + func (d *PropertyDescriptor) SetGet(v Value) + func (d *PropertyDescriptor) SetSet(v Value) + func (d *PropertyDescriptor) SetValue(v Value) + func (d *PropertyDescriptor) SetWritable(b bool) + func (d PropertyDescriptor) Attrs() uint8 + func (d PropertyDescriptor) Configurable() bool + func (d PropertyDescriptor) Enumerable() bool + func (d PropertyDescriptor) GetterObject() *Object + func (d PropertyDescriptor) HasConfigurable() bool + func (d PropertyDescriptor) HasEnumerable() bool + func (d PropertyDescriptor) HasGet() bool + func (d PropertyDescriptor) HasSet() bool + func (d PropertyDescriptor) HasValue() bool + func (d PropertyDescriptor) HasWritable() bool + func (d PropertyDescriptor) IsAccessorDescriptor() bool + func (d PropertyDescriptor) IsDataDescriptor() bool + func (d PropertyDescriptor) IsGenericDescriptor() bool + func (d PropertyDescriptor) SetterObject() *Object + func (d PropertyDescriptor) Writable() bool + type PropertyKey struct + func IndexKey(i uint32) PropertyKey + func InternKey(g string) PropertyKey + func PrivateKey(pn *PrivateName) PropertyKey + func StringKey(s *String) PropertyKey + func SymbolKey(s *Symbol) PropertyKey + func (k PropertyKey) GoString() string + func (k PropertyKey) Index() uint32 + func (k PropertyKey) IsIndex() bool + func (k PropertyKey) IsPrivate() bool + func (k PropertyKey) IsString() bool + func (k PropertyKey) IsSymbol() bool + func (k PropertyKey) String() *String + func (k PropertyKey) Symbol() *Symbol + func (k PropertyKey) ToJSString(r *Realm) *String + func (k PropertyKey) Value() Value + type Realm struct + Global *Object + func NewRealm() *Realm + func NewRealmWith(opts RealmOptions) *Realm + func (r *Realm) Add(a, b Value) (Value, error) + func (r *Realm) AddLiveRoots(roots func(add func(Value))) (remove func()) + func (r *Realm) AllocIC(fn *bytecode.Function, count uint32) (uint32, error) + func (r *Realm) AppendJSON(dst []byte, v Value) ([]byte, bool, error) + func (r *Realm) AppendJSONWith(dst []byte, v Value, opts JSONOptions) ([]byte, bool, error) + func (r *Realm) Call(fn Value, this Value, args []Value) (Value, error) + func (r *Realm) CallDepth() int + func (r *Realm) CallObject(fn *Object, this Value, args []Value) (Value, error) + func (r *Realm) CallState() CallState + func (r *Realm) CanToGoIntoDirect(v Value) bool + func (r *Realm) CanUnmarshalDirect(v Value) bool + func (r *Realm) ChargeMemory(n int) error + func (r *Realm) CheckAccessorFunction(v Value, setter bool) error + func (r *Realm) CheckInterrupt() error + func (r *Realm) ClearInterrupt() + func (r *Realm) Concat(a, b *String) (*String, error) + func (r *Realm) Construct(fn Value, args []Value, newTarget *Object) (Value, error) + func (r *Realm) CreateListFromArrayLike(v Value) ([]Value, error) + func (r *Realm) DateTime(tv float64) time.Time + func (r *Realm) DetachArrayBuffer(v Value) error + func (r *Realm) DisplayString(v Value) string + func (r *Realm) DropJobs(err error) + func (r *Realm) DynamicCodeDisabled() bool + func (r *Realm) EnterCall() error + func (r *Realm) EnumerableOwnKeys(o *Object) ([]PropertyKey, error) + func (r *Realm) ErrorConstructorFor(kind ErrorKind) *Object + func (r *Realm) ErrorPrototypeFor(kind ErrorKind) *Object + func (r *Realm) EvalScript(name, src string) (Value, error) + func (r *Realm) EvaluateGraph(g *ModuleGraph) (*ModuleEnv, *Object, error) + func (r *Realm) EvaluateModule(code *bytecode.Function) (*ModuleEnv, error) + func (r *Realm) EvaluateModuleAsync(code *bytecode.Function) (*ModuleEnv, *Object, error) + func (r *Realm) ExitCall() + func (r *Realm) FromGo(v any) (Value, error) + func (r *Realm) FromPropertyDescriptor(d PropertyDescriptor) Value + func (r *Realm) GetMethod(v Value, key PropertyKey) (Value, error) + func (r *Realm) GetPrototypeFromConstructor(newTarget, ctor, intrinsicDefault *Object) (*Object, error) + func (r *Realm) GetV(v Value, key PropertyKey) (Value, error) + func (r *Realm) GraphBinding(g *ModuleGraph, b ModuleBinding) (Value, bool) + func (r *Realm) GraphRan(g *ModuleGraph) bool + func (r *Realm) GreaterThan(x, y Value) (bool, error) + func (r *Realm) GreaterThanOrEqual(x, y Value) (bool, error) + func (r *Realm) HasOwn(o *Object, key PropertyKey) (bool, error) + func (r *Realm) HasPropertyIn(key, target Value) (bool, error) + func (r *Realm) HasSharedIntrinsics() bool + func (r *Realm) HoldJobs() + func (r *Realm) ICSlots() []ICEntry + func (r *Realm) ImportHooks() *ImportHooks + func (r *Realm) InstanceOf(v, target Value) (bool, error) + func (r *Realm) Intern(s *String) *String + func (r *Realm) InternGoString(g string) *String + func (r *Realm) Interrupt(v any) + func (r *Realm) Interrupted() bool + func (r *Realm) IsArray(v Value) (bool, error) + func (r *Realm) IsForeign(v Value) bool + func (r *Realm) IsLessThan(x, y Value, leftFirst bool) (int8, error) + func (r *Realm) JSONParse(text *String) (Value, error) + func (r *Realm) JSONParseGoString(text string) (Value, error) + func (r *Realm) JSONStringify(v Value) (*String, error) + func (r *Realm) JobsPending() bool + func (r *Realm) KeyFromGoString(g string) PropertyKey + func (r *Realm) KeyFromString(s *String) PropertyKey + func (r *Realm) LengthOfArrayLike(o *Object) (int64, error) + func (r *Realm) LessThan(x, y Value) (bool, error) + func (r *Realm) LessThanOrEqual(x, y Value) (bool, error) + func (r *Realm) Locale() string + func (r *Realm) LooseEquals(a, b Value) (bool, error) + func (r *Realm) MaxDynamicSource() int + func (r *Realm) MeasureLive(roots func(add func(Value))) int64 + func (r *Realm) MeasureToGo(v Value, opts DecodeOptions) (measured bool, err error) + func (r *Realm) MeasureUnmarshal(v Value, opts DecodeOptions) (measured bool, err error) + func (r *Realm) MemoryLimit() int64 + func (r *Realm) ModuleEvaluationError(p *Object, err error) error + func (r *Realm) NewArray(items ...Value) *Object + func (r *Realm) NewArrayBuffer(data []byte) (*Object, error) + func (r *Realm) NewArrayCap(n int) *Object + func (r *Realm) NewArrayFromSlice(items []Value) *Object + func (r *Realm) NewArrayLen(n uint32) *Object + func (r *Realm) NewBoundFunction(target *Object, boundThis Value, boundArgs []Value) (*Object, error) + func (r *Realm) NewDate(t time.Time) *Object + func (r *Realm) NewError(kind ErrorKind, format string, args ...any) *Object + func (r *Realm) NewErrorValue(kind ErrorKind, message *String) Value + func (r *Realm) NewHostFunction(name *String, length int, fn NativeFunc) *Object + func (r *Realm) NewHostPromise() *Object + func (r *Realm) NewNativeConstructor(name *String, length int, call NativeFunc, ctor NativeCtor) *Object + func (r *Realm) NewNativeDataFunction(name *String, length int, fn NativeDataFunc, data any) *Object + func (r *Realm) NewNativeFunction(name *String, length int, fn NativeFunc) *Object + func (r *Realm) NewObject() *Object + func (r *Realm) NewObjectCap(n int) *Object + func (r *Realm) NewObjectFrom(t *ObjectTemplate, vals []Value) *Object + func (r *Realm) NewObjectTemplate(proto *Object, keys []PropertyKey, attrs uint8) *ObjectTemplate + func (r *Realm) NewObjectWithProto(proto *Object) *Object + func (r *Realm) NewPromiseWithResolvers() (p, resolve, reject *Object) + func (r *Realm) NewRegExp(pattern, flags *String) (*Object, error) + func (r *Realm) NewStringObject(s *String) *Object + func (r *Realm) NewUint8Array(data []byte, proto *Object) (*Object, error) + func (r *Realm) OrdinaryCreateFromConstructor(newTarget *Object, defaultProto *Object, class Class) (*Object, error) + func (r *Realm) OrdinaryHasInstance(c, o Value) (bool, error) + func (r *Realm) OrdinaryToPrimitive(o *Object, hint Hint) (Value, error) + func (r *Realm) OwnKeys(o *Object) ([]PropertyKey, error) + func (r *Realm) ProtoEpoch() uint32 + func (r *Realm) PrototypeOf(o *Object) (*Object, error) + func (r *Realm) RangeError(format string, args ...any) error + func (r *Realm) RebaseAllocation(roots func(add func(Value))) error + func (r *Realm) ReferenceError(format string, args ...any) error + func (r *Realm) RegExpExec(rx *Object, s *String) (Value, error) + func (r *Realm) ReleaseCallData() + func (r *Realm) ReleaseJobs(err error) error + func (r *Realm) ReleaseScratch() + func (r *Realm) ResetAllocation() + func (r *Realm) RestoreCallState(cs CallState) + func (r *Realm) RunScript(code *bytecode.Function) (Value, error) + func (r *Realm) SetDynamicCodeDisabled(disabled bool) + func (r *Realm) SetHostDefined(code *bytecode.Function, host any) error + func (r *Realm) SetImportHooks(h *ImportHooks) + func (r *Realm) SetLocale(tag string) + func (r *Realm) SetMaxDynamicSource(n int) + func (r *Realm) SetMemoryLimit(n int64) + func (r *Realm) SetNow(now func() time.Time) + func (r *Realm) SetPromiseRejectionTracker(f func(p *Object, op PromiseRejectionOperation)) + func (r *Realm) SetStackHooks(capture func(r *Realm) []StackFrame, ...) + func (r *Realm) SetTimeZone(loc *time.Location) + func (r *Realm) SetV(target Value, key PropertyKey, v Value) error + func (r *Realm) SettlePromise(p *Object, v Value, reject bool) error + func (r *Realm) StackTrace(v Value) string + func (r *Realm) StartRebase() bool + func (r *Realm) Stats() Stats + func (r *Realm) SyntaxError(format string, args ...any) error + func (r *Realm) Throw(v Value) error + func (r *Realm) ThrownValue(err error) (v Value, ok bool) + func (r *Realm) TimeZone() *time.Location + func (r *Realm) ToBigInt(v Value) (*BigInt, error) + func (r *Realm) ToBigInt64(v Value) (int64, error) + func (r *Realm) ToBigUint64(v Value) (uint64, error) + func (r *Realm) ToGo(v Value) any + func (r *Realm) ToGoInto(v Value, target any) (complete bool) + func (r *Realm) ToGoStrict(v Value) (any, error) + func (r *Realm) ToIndex(v Value) (int64, error) + func (r *Realm) ToInt32(v Value) (int32, error) + func (r *Realm) ToIntegerOrInfinity(v Value) (float64, error) + func (r *Realm) ToLength(v Value) (int64, error) + func (r *Realm) ToNumber(v Value) (float64, error) + func (r *Realm) ToNumeric(v Value) (Value, error) + func (r *Realm) ToObject(v Value) (*Object, error) + func (r *Realm) ToPrimitive(v Value, hint Hint) (Value, error) + func (r *Realm) ToPropertyKey(v Value) (PropertyKey, error) + func (r *Realm) ToString(v Value) (*String, error) + func (r *Realm) ToUint32(v Value) (uint32, error) + func (r *Realm) TypeError(format string, args ...any) error + func (r *Realm) URIError(format string, args ...any) error + func (r *Realm) Unmarshal(v Value, target any) (complete bool, err error) + type RealmOptions struct + DisableDynamicCode bool + Locale string + MaxDynamicSource int + MemoryLimit int64 + SharedIntrinsics bool + TimeZone *time.Location + type RegExpData struct + func (d *RegExpData) Flags() *String + func (d *RegExpData) Source() *String + type Shape struct + func (s *Shape) Count() int + func (s *Shape) IsDictionary() bool + func (s *Shape) IsShared() bool + func (s *Shape) Lookup(key PropertyKey) (slot uint32, attrs uint8, ok bool) + func (s *Shape) Props() []shapeProp + func (s *Shape) Proto() *Object + type StackFrame struct + Flags uint32 + Fn *Object + PC uint32 + Recv *Object + func (f StackFrame) Code() *bytecode.Function + type Stats struct + AllocatedBytes int64 + ICEntries int + Interrupts int64 + LastMemoryLimitError *MemoryLimitError + LiveBytes int64 + MemoryLimitHits int64 + Objects int64 + PendingJobs int + RegisterStackBytes int64 + RequestAllocatedBytes int64 + Shapes int64 + Strings int64 + type String struct + func EmptyString() *String + func FromGoString(s string) *String + func FromHostString(text string) *String + func FromUTF16(u []uint16) *String + func LookupStaticAtom(name string) (*String, bool) + func NumberToString(f float64) *String + func TrimJSWhitespace(s *String) *String + func TypeOf(v Value) *String + func (s *String) ASCII() (string, bool) + func (s *String) At(i int) uint16 + func (s *String) Compare(t *String) int + func (s *String) Equals(t *String) bool + func (s *String) EqualsGoString(g string) bool + func (s *String) GoString() string + func (s *String) Hash() uint32 + func (s *String) IndexOf(sub *String, from int) int + func (s *String) IsASCII() bool + func (s *String) IsInterned() bool + func (s *String) IsWellFormed() bool + func (s *String) Len() int + func (s *String) String() string + func (s *String) Substring(start, end int) *String + func (s *String) UTF16() []uint16 + type StringBuilder struct + func (sb *StringBuilder) Grow(n int) + func (sb *StringBuilder) Len() int + func (sb *StringBuilder) Reset() + func (sb *StringBuilder) String() *String + func (sb *StringBuilder) WriteASCII(c byte) + func (sb *StringBuilder) WriteGoString(s string) + func (sb *StringBuilder) WriteRune(r rune) + func (sb *StringBuilder) WriteString(s *String) + func (sb *StringBuilder) WriteUTF16(u []uint16) + func (sb *StringBuilder) WriteUnit(c uint16) + type Symbol struct + func NewSymbol(description *String) *Symbol + func (s *Symbol) Description() *String + type Type uint8 + const TypeBigInt + const TypeBoolean + const TypeHole + const TypeNull + const TypeNumber + const TypeObject + const TypeString + const TypeSymbol + const TypeUndefined + type Value struct + func Arg(args []Value, i int) Value + func BigIntValue(b *BigInt) Value + func Bool(b bool) Value + func False() Value + func Hole() Value + func Int64Value(i int64) Value + func IntValue(i int) Value + func NaN() Value + func Null() Value + func NumberValue(f float64) Value + func ObjectValue(o *Object) Value + func StringValue(s *String) Value + func SymbolValue(s *Symbol) Value + func True() Value + func Uint32Value(i uint32) Value + func Undefined() Value + func (v Value) AsBigInt() *BigInt + func (v Value) AsBool() bool + func (v Value) AsNumber() float64 + func (v Value) AsObject() *Object + func (v Value) AsString() *String + func (v Value) AsSymbol() *Symbol + func (v Value) Bits() uint64 + func (v Value) IsArrayIndex() (uint32, bool) + func (v Value) IsBigInt() bool + func (v Value) IsBool() bool + func (v Value) IsFalse() bool + func (v Value) IsHole() bool + func (v Value) IsInt32() (int32, bool) + func (v Value) IsNull() bool + func (v Value) IsNullish() bool + func (v Value) IsNumber() bool + func (v Value) IsObject() bool + func (v Value) IsPrimitive() bool + func (v Value) IsString() bool + func (v Value) IsSymbol() bool + func (v Value) IsTrue() bool + func (v Value) IsUndefined() bool + func (v Value) String() string + func (v Value) Type() Type v0.1.0-alpha.11 Oct 27, 2026