js_interpreter
library
Classes
ArrayExpression
Array expression (1, 2, 3)
ArrayPattern
Array destructuring pattern (a, b, ...rest = arr)
ArrayPrototype
Array prototype with all methods
ArrowFunctionExpression
Arrow function expression (param) => expr or (param1, param2) => { body }
AssignmentExpression
Assignment expression (a = b, x += 5)
AssignmentPattern
Pattern with default value (a = 10 in a = 10 = arr)
ASTNode
Base class for all AST nodes
ASTVisitor <T >
Interface for the Visitor pattern
AsyncArrowFunctionExpression
Async arrow function expression: async (param1, param2) => body
AsyncFunctionDeclaration
Async function declaration
AsyncFunctionExpression
Async function expression
AwaitExpression
Await expression: await promise
AwaitUsingDeclaration
Await-using declaration: 'await using x = resource;'
BigIntPrototype
Prototype pour les BigInt
BinaryExpression
Binary expression (a + b, a == b, etc.)
Binding
Represents a variable binding in the environment
BlockStatement
Block statement ({ ... })
BooleanPrototype
Boolean prototype avec methodes
BreakStatement
Break statement
CallExpression
Function call expression (foo(), obj.method(a, b))
CatchClause
Catch clause of a try/catch
ClassBody
Class body (contains methods, fields, and static blocks)
ClassDeclaration
Class declaration
ClassExpression
Class expression (for use in expressions like: const MyClass = class { ... })
ClassMember
Base class for all class members
ConditionalExpression
Ternary conditional expression (a ? b : c)
ConsoleObject
Console object implementation
ContinueStatement
Continue statement
DartValueConverter
Class to convert JavaScript values to native Dart types
DateObject
JavaScript Date Object implementation
Declaration
Base class for all declarations
Note: Declarations are also statements in JavaScript
DestructuringAssignmentExpression
Assignment with destructuring (a, b = arr or {x, y} = obj)
DoWhileStatement
Do-while statement
DynamicFunction
Function created dynamically via new Function(params, body)
This function parses and executes its body code when called
EmptyStatement
Empty statement (semicolon alone)
Environment
JavaScript lexical environment (scope)
ExecutionContext
JavaScript execution context
ExecutionStack
JavaScript execution stack
ExportAllDeclaration
Export all exports of a module (export * from 'module')
ExportDeclaration
Base class for export declarations
ExportDeclarationStatement
Export of declaration (export const/let/var/function/class)
ExportDefaultDeclaration
Default export (export default expression)
ExportNamedDeclaration
Named export (export { name })
ExportSpecifier
Export specifier
Expression
Base class for all expressions
ExpressionPattern
Pattern for an expression (like a member expression in rest patterns)
Example: ...obj.prop or ...objkey
ExpressionStatement
Expression statement (expression followed by semicolon)
FieldDeclaration
Class field declaration
ForInStatement
For-in statement
ForOfStatement
For-of statement
ForStatement
For statement
FunctionDeclaration
Function declaration
FunctionExpression
Function expression: function(param1, param2) { body }
FunctionGlobal
Global Function object with constructor and static methods
FunctionObject
A wrapper object that presents a JSFunction as a JSObject
This allows functions to be used with Object.getOwnPropertyNames, etc.
FunctionPrototype
Function.prototype - methods available on all functions
GlobalFunctions
Global JavaScript functions implementation
IdentifierExpression
Identifier expression (variables, function names)
IdentifierPattern
Identifier pattern (x in x = arr)
IfStatement
If/else statement
ImportDeclaration
Import declaration
ImportDefaultSpecifier
Default import specifier
ImportExpression
Dynamic import (import('module'))
ImportNamespaceSpecifier
Namespace import specifier (* as name)
ImportSpecifier
Named import specifier
IntlObject
JavaScript Intl API implementation using Dart's intl package
IteratorUtils
JSArray
Array JavaScript
JSArrayBuffer
ArrayBuffer: represents a raw binary data buffer
JSArrayIterator
Implementation of an array iterator
JSArrowFunction
Support for arrow functions (arrow functions)
JSAsyncArrowFunction
Async arrow function - similar to JSArrowFunction but for async arrows
JSAsyncGenerator
Async generator JavaScript (ES2018)
Similar to JSGenerator but .next() returns a Promise that resolves to {value, done}
JSBigInt
Representation of a JavaScript BigInt
JSBigInt64Array
BigInt64Array: 64-bit signed integer array using BigInt values
JSBigIntObject
JSBigUint64Array
BigUint64Array: 64-bit unsigned integer array using BigInt values
JSBoolean
Boolean value
JSBooleanObject
JSBoundFunction
"Bound" function created by Function.prototype.bind()
JSClass
Classe JavaScript (ES6 class)
JSConversion
JSDataView
DataView : vue flexible sur un ArrayBuffer
Permet de lire/ecrire des types differents a des positions arbitraires
JSDate
JavaScript Date value type
JSErrorObjectFactory
Factory to create JavaScript Error objects
JSFinalizationRegistryObject
JSFloat16Array
Float16Array : tableau de flottants 16 bits (half-precision IEEE 754)
JSFloat32Array
Float32Array : tableau de flottants 32 bits (IEEE 754)
JSFloat64Array
Float64Array : tableau de flottants 64 bits (IEEE 754)
JSFunction
Fonction JavaScript
JSGenerator
JavaScript generator
JSGlobalThis
Implementation de globalThis JavaScript
Fournit l'acces a l'environnement global
JSInt16Array
Int16Array : tableau d'entiers signes 16 bits
JSInt32Array
Int32Array : tableau d'entiers signes 32 bits
JSInt8Array
Int8Array : tableau d'entiers signes 8 bits
JSInterpreter
Main JavaScript engine
JSIterator
Interface for JavaScript iterators
Conforms to the ECMAScript iteration protocol
JSIteratorResult
Iteration result {value, done}
JSLexer
JavaScript Lexical Analyzer
JSMap
Objet Map JavaScript
JSMapIterator
Implementation of a map iterator
JSMappedArguments
Mapped arguments object for non-strict functions with simple parameters
In ES5, when a function has simple (non-rest, non-destructured) parameters,
the arguments object is "mapped" - changes to argumentsi also change the parameter,
and vice versa. This only applies in non-strict mode.
JSModule
JSNativeFunction
Native JavaScript function
JSNull
Null value
JSNumber
Number value
JSNumberObject
JSObject
Classes for wrapper objects (forward declarations)
JSONObject
JavaScript JSON Object implementation
JSParser
JavaScript Syntax Analyzer (Recursive Descent Parser)
JSPromise
JavaScript Promise object
JSProxy
Proxy implementation - Metaprogramming proxy with traps
JSRealm
Represents a JavaScript Realm - an isolated execution environment
with its own global object and intrinsic objects.
JSRealmFactory
Factory for creating Realm-related JavaScript objects
JSReflect
Reflect implementation - Reflection API companion to Proxy
JSRegExp
JavaScript RegExp object - represents a regular expression
JSRegExpFactory
Factory to create JavaScript RegExp
JSRegExpMatchIterator
Support iteration for String
Now integrated directly into JSString via extension
Utilities for iteration
ES2020: Implementation of a regex match iterator for matchAll()
JSRuntime
Global function caller / runtime interface.
JSSet
Objet Set JavaScript
JSSetIterator
Implementation d'un iterateur de set
JSString
String value
JSStringIterator
Implementation of a string iterator
JSStringObject
Objet wrapper String JavaScript (cree avec new String(...))
Contrairement a JSString (primitive), c'est an object avec des propertes
JSSymbol
Implementation of JavaScript Symbol
NOTE: JSSymbol extends JSValue (not JSObject) because symbols are primitives
JSSymbolConstructor
Symbol constructor for JavaScript
JSSymbolObject
Symbol object wrapper - Object wrapper for symbol primitives
JSTemporalDuration
JSTemporalInstant
JSTemporalPlainDate
JSTemporalPlainDateTime
JSTemporalPlainMonthDay
JSTemporalPlainTime
JSTemporalPlainYearMonth
JSTemporalZonedDateTime
JSTypedArray
Base class for all TypedArrays
JSTypedArrayIterator
Iterateur pour TypedArrays
JSUint16Array
Uint16Array : tableau d'entiers non signes 16 bits
JSUint32Array
Uint32Array : tableau d'entiers non signes 32 bits
JSUint8Array
Uint8Array : tableau d'entiers non signes 8 bits
JSUint8ClampedArray
Uint8ClampedArray : comme Uint8Array mais avec clamping sur les valeurs
JSUndefined
Undefined value
JSValue
Abstract base class for all JavaScript values
JSValueFactory
Factory to create JSValue
JSWeakMap
WeakMap implementation - Map with weak references to keys
JSWeakRefObject
JSWeakSet
WeakSet implementation - Set with weak references to values
LabeledStatement
Labeled statement (label:)
LiteralExpression
Literal expression (numbers, strings, booleans, null, undefined)
MapPrototype
Prototype pour les objets Map
MathObject
Math object with all methods and constants
MemberExpression
Member access expression (obj.prop, objkey)
MessageSystem
Message system for pub/sub communication between Dart and JavaScript
MetaProperty
Meta property (import.meta)
MethodDefinition
Method definition in a class
ModuleDeclaration
Base class for module declarations
NewExpression
New expression (new Foo(), new Array(1, 2, 3))
NullishCoalescingExpression
Nullish coalescing expression: left ?? right
NumberPrototype
Prototype for numbers
ObjectExpression
Object literal expression ({a: 1, b: 2, ...other})
ObjectGlobal
Global Object with its static methods
ObjectPattern
Object destructuring pattern ({a, b: newName, ...rest} = obj)
ObjectPatternProperty
Property in an object pattern
ObjectProperty
Object literal property
ObjectPrototype
Object Prototype - methods available on all objects
OptionalChainingExpression
Optional chaining expression: obj?.prop or obj?.method()
Parameter
Function parameter
Pattern
Base class for destructuring patterns
PrivateIdentifierExpression
Private identifier expression (#privateField)
Program
Root node of the program
PromisePrototype
Prototype for Promise objects
PromiseStaticMethod
Specialized class for Promise static methods
that validate this binding and pass it to nativeImpl
PropertyDescriptor
JavaScript property descriptor for managing getters/setters
PrototypeManager
Manages prototypes for a single JavaScript interpreter instance.
This ensures each interpreter has its own isolated prototype chain.
RegexLiteralExpression
Regular expression literal (/pattern/flags)
RegExpGlobal
Global RegExp object
ReturnStatement
Return statement
RuntimeCallableFunction
Specialized function objects that can execute directly on any runtime.
SequenceExpression
Sequence expression: (expr1, expr2, expr3)
SetPrototype
Prototype pour les objets Set
SpreadElement
Spread element: ...expression (used in arrays, objects, function calls)
Statement
Base class for all statements
StaticBlockDeclaration
Static block declaration for a class
StringPrototype
String prototype with all the methods
SuperExpression
'super' expression
SwitchCase
Case in a switch statement
SwitchStatement
Switch statement
TaggedTemplateExpression
Tagged template literal: tagtemplate or tagHello ${name}!
TemplateLiteralExpression
Template literal with interpolation (Hello ${name}!)
TextDecoder
Implementation of TextDecoder
TextDecoderInstance
TextDecoder instance (JavaScript object)
TextEncoder
Implementation de TextEncoder
TextEncoderInstance
TextEncoder instance (JavaScript object)
ThisExpression
'this' expression
ThrowStatement
Throw statement for raising exceptions
TimeoutManager
Manages active timeouts for setTimeout/clearTimeout functionality
Token
Represents a token with its position in the source code
TokenUtils
Utilities for tokens
TryStatement
Try/catch/finally statement for exception handling
UnaryExpression
Unary expression (!a, -b, typeof x)
UsingStatement
Using statement (ES: using declaration with statement body)
Syntax: using x = expr { ... } or await using x = expr { ... }
VariableDeclaration
Variable declaration (var, let, const)
VariableDeclarator
Variable declarator (for var a = 1, b = 2)
WhileStatement
While statement
WithEnvironment
Environment wrapper for with statements
Delegates property lookups to an object before checking environment bindings
WithStatement
With statement (forbidden in strict mode)
YieldExpression
Yield expression (used in generators)
Exceptions / Errors
EnvironmentError
Exceptions for environment errors
FlowControlException
Exception for JavaScript flow control
JSAggregateError
AggregateError ES2021 - error containing multiple errors
JSError
Base exception for JavaScript errors
JSException
JavaScript Exception - for errors thrown by throw
This class represents JavaScript exceptions that can be caught by catch
JSRangeError
JavaScript RangeError - for out of range values
JSReferenceError
JavaScript ReferenceError - for undefined variables
JSSyntaxError
JavaScript SyntaxError - for parsing
JSTypeError
JavaScript TypeError - for operations on wrong types
JSURIError
JavaScript URIError - for invalid URI operations
LexerError
Exception thrown during lexical analysis errors
ParseError
Exception raised during syntax analysis errors
