@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

package/declaration/runtime-semantics/Block.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Block.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/Block.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,4BAA4B,EAAE,MAAM,oBAAoB,CAAC;AAQlE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,iEAAiE;AACjE,wBAAiB,6BAA6B,CAAC,IAAI,EAAE,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,SAAS,EAAE,GAAG,EAAE,4BAA4B,mCAiCpI;AAED,sEAAsE;AAItE,wBAAiB,cAAc,CAAC,EAAE,aAAa,EAAE,EAAE,SAAS,CAAC,KAAK,gKAmBjE"}

package/declaration/runtime-semantics/BreakStatement.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-break-statement-runtime-semantics-evaluation */
+export declare function Evaluate_BreakStatement({ LabelIdentifier }: ParseNode.BreakStatement): import("../completion.mts").BreakCompletion;
+//# sourceMappingURL=BreakStatement.d.mts.map

package/declaration/runtime-semantics/BreakStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BreakStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/BreakStatement.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,gFAAgF;AAIhF,wBAAgB,uBAAuB,CAAC,EAAE,eAAe,EAAE,EAAE,SAAS,CAAC,cAAc,+CASpF"}

package/declaration/runtime-semantics/BreakableStatement.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation */
+export declare function Evaluate_BreakableStatement(BreakableStatement: ParseNode.BreakableStatement): import("../evaluator.mts").StatementEvaluator;
+//# sourceMappingURL=BreakableStatement.d.mts.map

package/declaration/runtime-semantics/BreakableStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BreakableStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/BreakableStatement.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,oFAAoF;AAQpF,wBAAgB,2BAA2B,CAAC,kBAAkB,EAAE,SAAS,CAAC,kBAAkB,iDAK3F"}

package/declaration/runtime-semantics/CallExpression.d.mts

@@ -0,0 +1,5 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation */
+export declare function Evaluate_CallExpression(CallExpression: ParseNode.CallExpression): ValueEvaluator;
+//# sourceMappingURL=CallExpression.d.mts.map

package/declaration/runtime-semantics/CallExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CallExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/CallExpression.mts"],"names":[],"mappings":"AAUA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,+EAA+E;AAI/E,wBAAiB,uBAAuB,CAAC,cAAc,EAAE,SAAS,CAAC,cAAc,GAAG,cAAc,CAwCjG"}

package/declaration/runtime-semantics/ClassDeclaration.d.mts

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator, ValueEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-bindingclassdeclarationevaluation */
+export declare function BindingClassDeclarationEvaluation(ClassDeclaration: ParseNode.ClassDeclaration): ValueEvaluator;
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_ClassDeclaration(ClassDeclaration: ParseNode.ClassDeclaration): PlainEvaluator;
+//# sourceMappingURL=ClassDeclaration.d.mts.map

package/declaration/runtime-semantics/ClassDeclaration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ClassDeclaration.mts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvE,uFAAuF;AAIvF,wBAAiB,iCAAiC,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,GAAG,cAAc,CAgB/G;AAED,kFAAkF;AAElF,wBAAiB,yBAAyB,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,GAAG,cAAc,CAKvG"}

package/declaration/runtime-semantics/ClassDefinitionEvaluation.d.mts

@@ -0,0 +1,18 @@
+import { Value, PrivateName, JSStringValue, UndefinedValue, type PropertyKeyValue } from '../value.mts';
+import { type ECMAScriptFunctionObject, type BuiltinFunctionObject } from '../abstract-ops/all.mts';
+import { type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export interface DefaultConstructorBuiltinFunction extends BuiltinFunctionObject {
+    readonly PrivateMethods: ECMAScriptFunctionObject['PrivateMethods'];
+    readonly Fields: ECMAScriptFunctionObject['Fields'];
+    readonly SourceText: ECMAScriptFunctionObject['SourceText'];
+    readonly ConstructorKind: ECMAScriptFunctionObject['ConstructorKind'];
+}
+export declare function ClassDefinitionEvaluation(ClassTail: ParseNode.ClassTail, classBinding: JSStringValue | UndefinedValue, className: PropertyKeyValue | PrivateName, sourceText: string): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | Mutable<DefaultConstructorBuiltinFunction>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=ClassDefinitionEvaluation.d.mts.map

package/declaration/runtime-semantics/ClassDefinitionEvaluation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassDefinitionEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ClassDefinitionEvaluation.mts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EAA0B,WAAW,EAE1C,aAAa,EAGb,cAAc,EACd,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AAEtB,OAAO,EAiBL,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAejC,OAAO,EAA2B,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA2BzD,MAAM,WAAW,iCAAkC,SAAQ,qBAAqB;IAC9E,QAAQ,CAAC,cAAc,EAAE,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;IACpE,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IACpD,QAAQ,CAAC,UAAU,EAAE,wBAAwB,CAAC,YAAY,CAAC,CAAC;IAC5D,QAAQ,CAAC,eAAe,EAAE,wBAAwB,CAAC,iBAAiB,CAAC,CAAC;CACvE;AAGD,wBAAiB,yBAAyB,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,GAAG,cAAc,EAAE,SAAS,EAAE,gBAAgB,GAAG,WAAW,EAAE,UAAU,EAAE,MAAM;;;;;;8FA8QrL"}

package/declaration/runtime-semantics/ClassExpression.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_ClassExpression(ClassExpression: ParseNode.ClassExpression): ValueEvaluator;
+//# sourceMappingURL=ClassExpression.d.mts.map

package/declaration/runtime-semantics/ClassExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ClassExpression.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,kFAAkF;AAIlF,wBAAiB,wBAAwB,CAAC,eAAe,EAAE,SAAS,CAAC,eAAe,GAAG,cAAc,CAWpG"}

package/declaration/runtime-semantics/ClassFieldDefinitionEvaluation.d.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import type { ECMAScriptFunctionObject, ObjectValue, PrivateName, PropertyKeyValue } from '#self';
+export declare class ClassFieldDefinitionRecord {
+    Name: PropertyKeyValue | PrivateName;
+    Initializer: ECMAScriptFunctionObject | undefined;
+    constructor(init: ClassFieldDefinitionRecord);
+}
+export declare function ClassFieldDefinitionEvaluation(FieldDefinition: ParseNode.FieldDefinition, homeObject: ObjectValue): PlainEvaluator<ClassFieldDefinitionRecord>;
+//# sourceMappingURL=ClassFieldDefinitionEvaluation.d.mts.map

package/declaration/runtime-semantics/ClassFieldDefinitionEvaluation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassFieldDefinitionEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ClassFieldDefinitionEvaluation.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EACV,wBAAwB,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EACrE,MAAM,OAAO,CAAC;AAEf,qBAAa,0BAA0B;IACrC,IAAI,EAAE,gBAAgB,GAAG,WAAW,CAAC;IAErC,WAAW,EAAE,wBAAwB,GAAG,SAAS,CAAC;gBAEtC,IAAI,EAAE,0BAA0B;CAI7C;AAED,wBAAiB,8BAA8B,CAAC,eAAe,EAAE,SAAS,CAAC,eAAe,EAAE,UAAU,EAAE,WAAW,GAAG,cAAc,CAAC,0BAA0B,CAAC,CAsC/J"}

package/declaration/runtime-semantics/ClassStaticBlockDefinitionEvaluation.d.mts

@@ -0,0 +1,10 @@
+import { type ECMAScriptFunctionObject } from '../abstract-ops/all.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ObjectValue } from '#self';
+export declare class ClassStaticBlockDefinitionRecord {
+    BodyFunction: ECMAScriptFunctionObject;
+    constructor({ BodyFunction }: ClassStaticBlockDefinitionRecord);
+}
+/** https://tc39.es/ecma262/#sec-runtime-semantics-classstaticblockdefinitionevaluation */
+export declare function ClassStaticBlockDefinitionEvaluation({ ClassStaticBlockBody }: ParseNode.ClassStaticBlock, homeObject: ObjectValue): ClassStaticBlockDefinitionRecord;
+//# sourceMappingURL=ClassStaticBlockDefinitionEvaluation.d.mts.map

package/declaration/runtime-semantics/ClassStaticBlockDefinitionEvaluation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClassStaticBlockDefinitionEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ClassStaticBlockDefinitionEvaluation.mts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC,qBAAa,gCAAgC;IAC3C,YAAY,EAAE,wBAAwB,CAAC;gBAE3B,EAAE,YAAY,EAAE,EAAE,gCAAgC;CAG/D;AAED,0FAA0F;AAE1F,wBAAgB,oCAAoC,CAAC,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,gBAAgB,EAAE,UAAU,EAAE,WAAW,oCAuBjI"}

package/declaration/runtime-semantics/CoalesceExpression.d.mts

@@ -0,0 +1,5 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-binary-logical-operators-runtime-semantics-evaluation */
+export declare function Evaluate_CoalesceExpression({ CoalesceExpressionHead, BitwiseORExpression }: ParseNode.CoalesceExpression): ValueEvaluator;
+//# sourceMappingURL=CoalesceExpression.d.mts.map

package/declaration/runtime-semantics/CoalesceExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoalesceExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/CoalesceExpression.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,yFAAyF;AAGzF,wBAAiB,2BAA2B,CAAC,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,EAAE,SAAS,CAAC,kBAAkB,GAAG,cAAc,CAc1I"}

package/declaration/runtime-semantics/CommaOperator.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ValueEvaluator } from '#self';
+/** https://tc39.es/ecma262/#sec-comma-operator-runtime-semantics-evaluation */
+export declare function Evaluate_CommaOperator({ ExpressionList }: ParseNode.CommaOperator): ValueEvaluator;
+//# sourceMappingURL=CommaOperator.d.mts.map

package/declaration/runtime-semantics/CommaOperator.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CommaOperator.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/CommaOperator.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAS,cAAc,EAAE,MAAM,OAAO,CAAC;AAEnD,+EAA+E;AAI/E,wBAAiB,sBAAsB,CAAC,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,aAAa,GAAG,cAAc,CAOnG"}

package/declaration/runtime-semantics/ConditionalExpression.d.mts

@@ -0,0 +1,5 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-conditional-operator-runtime-semantics-evaluation */
+export declare function Evaluate_ConditionalExpression({ ShortCircuitExpression, AssignmentExpression_a, AssignmentExpression_b, }: ParseNode.ConditionalExpression): ValueEvaluator;
+//# sourceMappingURL=ConditionalExpression.d.mts.map

package/declaration/runtime-semantics/ConditionalExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConditionalExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ConditionalExpression.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qFAAqF;AAGrF,wBAAiB,8BAA8B,CAAC,EAC9C,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,GACvB,EAAE,SAAS,CAAC,qBAAqB,GAAG,cAAc,CAiBlD"}

package/declaration/runtime-semantics/ContinueStatement.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-continue-statement-runtime-semantics-evaluation */
+export declare function Evaluate_ContinueStatement({ LabelIdentifier }: ParseNode.ContinueStatement): import("../completion.mts").ContinueCompletion;
+//# sourceMappingURL=ContinueStatement.d.mts.map

package/declaration/runtime-semantics/ContinueStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContinueStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ContinueStatement.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,mFAAmF;AAInF,wBAAgB,0BAA0B,CAAC,EAAE,eAAe,EAAE,EAAE,SAAS,CAAC,iBAAiB,kDAS1F"}

package/declaration/runtime-semantics/CreateDynamicFunction.d.mts

@@ -0,0 +1,10 @@
+import { type FunctionObject } from '../abstract-ops/all.mts';
+import { UndefinedValue, Value, type Arguments } from '../value.mts';
+export declare function CreateDynamicFunction(constructor: FunctionObject, newTarget: FunctionObject | UndefinedValue, kind: 'normal' | 'generator' | 'async' | 'asyncGenerator', args: Arguments): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | import("../helpers.mts").Mutable<import("../abstract-ops/function-operations.mts").ECMAScriptFunctionObject>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=CreateDynamicFunction.d.mts.map

package/declaration/runtime-semantics/CreateDynamicFunction.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CreateDynamicFunction.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/CreateDynamicFunction.mts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,cAAc,EAEpB,MAAM,yBAAyB,CAAC;AAQjC,OAAO,EACO,cAAc,EAAE,KAAK,EACjC,KAAK,SAAS,EACf,MAAM,cAAc,CAAC;AAYtB,wBAAiB,qBAAqB,CAAC,WAAW,EAAE,cAAc,EAAE,SAAS,EAAE,cAAc,GAAG,cAAc,EAAE,IAAI,EAAE,QAAQ,GAAG,WAAW,GAAG,OAAO,GAAG,gBAAgB,EAAE,IAAI,EAAE,SAAS;;;;;;gKAqKzL"}

package/declaration/runtime-semantics/DebuggerStatement.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type StatementEvaluator } from '#self';
+/** https://tc39.es/ecma262/#sec-debugger-statement-runtime-semantics-evaluation */
+export declare function Evaluate_DebuggerStatement(_node: ParseNode.DebuggerStatement): StatementEvaluator;
+//# sourceMappingURL=DebuggerStatement.d.mts.map

package/declaration/runtime-semantics/DebuggerStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DebuggerStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/DebuggerStatement.mts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAU,KAAK,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAExD,mFAAmF;AAEnF,wBAAiB,0BAA0B,CAAC,KAAK,EAAE,SAAS,CAAC,iBAAiB,GAAG,kBAAkB,CAWlG"}

package/declaration/runtime-semantics/DefineMethod.d.mts

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import type { ECMAScriptFunctionObject, ObjectValue, PrivateName, PropertyKeyValue } from '#self';
+export interface DefineMethodRecord {
+    readonly Key: PropertyKeyValue | PrivateName;
+    readonly Closure: ECMAScriptFunctionObject;
+}
+/** https://tc39.es/ecma262/#sec-runtime-semantics-definemethod */
+export declare function DefineMethod(MethodDefinition: ParseNode.MethodDefinition, object: ObjectValue, functionPrototype?: ObjectValue): PlainEvaluator<DefineMethodRecord>;
+//# sourceMappingURL=DefineMethod.d.mts.map

package/declaration/runtime-semantics/DefineMethod.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DefineMethod.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/DefineMethod.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EACV,wBAAwB,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EACrE,MAAM,OAAO,CAAC;AAEf,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,GAAG,EAAE,gBAAgB,GAAG,WAAW,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC;CAC5C;AACD,kEAAkE;AAClE,wBAAiB,YAAY,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,CAAC,EAAE,WAAW,GAAG,cAAc,CAAC,kBAAkB,CAAC,CAyBpK"}

package/declaration/runtime-semantics/DestructuringAssignmentEvaluation.d.mts

@@ -0,0 +1,5 @@
+import { Value } from '../value.mts';
+import { type StatementEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function DestructuringAssignmentEvaluation(node: ParseNode.ObjectAssignmentPattern | ParseNode.ArrayAssignmentPattern, value: Value): StatementEvaluator;
+//# sourceMappingURL=DestructuringAssignmentEvaluation.d.mts.map

package/declaration/runtime-semantics/DestructuringAssignmentEvaluation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DestructuringAssignmentEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/DestructuringAssignmentEvaluation.mts"],"names":[],"mappings":"AACA,OAAO,EAC2B,KAAK,EACtC,MAAM,cAAc,CAAC;AA0BtB,OAAO,EAC0B,KAAK,kBAAkB,EACvD,MAAM,kBAAkB,CAAC;AAS1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAgQzD,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,SAAS,CAAC,uBAAuB,GAAG,SAAS,CAAC,sBAAsB,EAAE,KAAK,EAAE,KAAK,GAAG,kBAAkB,CAS9J"}

package/declaration/runtime-semantics/EmptyStatement.d.mts

@@ -0,0 +1,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-empty-statement-runtime-semantics-evaluation */
+export declare function Evaluate_EmptyStatement(_EmptyStatement: ParseNode.EmptyStatement): NormalCompletion<undefined>;
+//# sourceMappingURL=EmptyStatement.d.mts.map

package/declaration/runtime-semantics/EmptyStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmptyStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EmptyStatement.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,gFAAgF;AAEhF,wBAAgB,uBAAuB,CAAC,eAAe,EAAE,SAAS,CAAC,cAAc,+BAGhF"}

package/declaration/runtime-semantics/EqualityExpression.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-equality-operators-runtime-semantics-evaluation */
+export declare function Evaluate_EqualityExpression({ EqualityExpression, operator, RelationalExpression }: ParseNode.EqualityExpression): Generator<import("../evaluator.mts").EvaluatorYieldType, import("../completion.mts").ValueCompletion<import("../value.mts").BooleanValue<boolean>>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=EqualityExpression.d.mts.map

package/declaration/runtime-semantics/EqualityExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EqualityExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EqualityExpression.mts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,mFAAmF;AAMnF,wBAAiB,2BAA2B,CAAC,EAAE,kBAAkB,EAAE,QAAQ,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,kBAAkB,qMA0ChI"}

package/declaration/runtime-semantics/EvaluateBody.d.mts

@@ -0,0 +1,37 @@
+import { Value, type Arguments } from '../value.mts';
+import { type ECMAScriptFunctionObject, type Body } from '../abstract-ops/all.mts';
+import { Completion } from '../completion.mts';
+import { type StatementEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function Evaluate_AnyFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody | ParseNode.AsyncBody | ParseNode.GeneratorBody | ParseNode.AsyncGeneratorBody): Generator<import("../evaluator.mts").EvaluatorYieldType, Completion<void | Value>, import("../evaluator.mts").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluatebody */
+export declare function EvaluateBody_FunctionBody({ FunctionStatementList }: ParseNode.FunctionBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("../evaluator.mts").EvaluatorYieldType, Completion<void | Value>, import("../evaluator.mts").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_ExpressionBody({ AssignmentExpression }: ParseNode.ExpressionBody): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-arrow-function-definitions-runtime-semantics-evaluatebody */
+export declare function EvaluateBody_ConciseBody({ ExpressionBody }: ParseNode.ConciseBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("../evaluator.mts").EvaluatorYieldType, void | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | import("../value.mts").JSStringValue | import("../value.mts").UndefinedValue | import("../value.mts").NullValue | import("../value.mts").BooleanValue<boolean> | import("../value.mts").SymbolValue | import("../value.mts").NumberValue | import("../value.mts").BigIntValue | import("../value.mts").ObjectValue | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | Value>, import("../evaluator.mts").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluatebody */
+export declare function EvaluateBody_GeneratorBody(GeneratorBody: ParseNode.GeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-evaluatebody */
+export declare function EvaluateBody_AsyncGeneratorBody(FunctionBody: ParseNode.AsyncGeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-async-function-definitions-EvaluateBody */
+export declare function EvaluateBody_AsyncFunctionBody(FunctionBody: ParseNode.AsyncBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+}, import("../evaluator.mts").EvaluatorNextType>;
+export declare function EvaluateBody_AssignmentExpression(AssignmentExpression: ParseNode.Initializer, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+export declare function EvaluateBody(Body: Body, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+//# sourceMappingURL=EvaluateBody.d.mts.map

package/declaration/runtime-semantics/EvaluateBody.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluateBody.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EvaluateBody.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EASL,KAAK,wBAAwB,EAG7B,KAAK,IAAI,EACV,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,UAAU,EAKX,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAY,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAQzD,wBAAgB,wBAAwB,CAAC,EAAE,qBAAqB,EAAE,EAAE,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,kBAAkB,oIAExK;AAED,uFAAuF;AAEvF,wBAAiB,yBAAyB,CAAC,EAAE,qBAAqB,EAAE,EAAE,SAAS,CAAC,YAAY,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,oIAK/J;AAED,2FAA2F;AAE3F,wBAAiB,uBAAuB,CAAC,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,cAAc,GAAG,kBAAkB,CAO/G;AAED,6FAA6F;AAE7F,wBAAiB,wBAAwB,CAAC,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,WAAW,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;;;;;;;6MAKtJ;AAqBD,iGAAiG;AAEjG,wBAAiB,0BAA0B,CAAC,aAAa,EAAE,SAAS,CAAC,aAAa,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAa1K;AAED,2EAA2E;AAE3E,wBAAiB,+BAA+B,CAAC,YAAY,EAAE,SAAS,CAAC,kBAAkB,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAiBnL;AAED,2EAA2E;AAE3E,wBAAiB,8BAA8B,CAAC,YAAY,EAAE,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;iDAepJ;AAID,wBAAiB,iCAAiC,CAAC,oBAAoB,EAAE,SAAS,CAAC,WAAW,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAkBtL;AAkBD,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,sBAmB1G"}

package/declaration/runtime-semantics/EvaluateCall.d.mts

@@ -0,0 +1,5 @@
+import { Value, ReferenceRecord } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-evaluatecall */
+export declare function EvaluateCall(func: Value, ref: ReferenceRecord | Value, args: ParseNode | ParseNode.Arguments, tailPosition: boolean): Generator<import("../evaluator.mts").EvaluatorYieldType, import("../completion.mts").ValueCompletion<Value>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=EvaluateCall.d.mts.map

package/declaration/runtime-semantics/EvaluateCall.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluateCall.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EvaluateCall.mts"],"names":[],"mappings":"AACA,OAAO,EACQ,KAAK,EAAE,eAAe,EACpC,MAAM,cAAc,CAAC;AAWtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,gDAAgD;AAChD,wBAAiB,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,eAAe,GAAG,KAAK,EAAE,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,8JA4CpI"}

package/declaration/runtime-semantics/EvaluatePropertyAccess.d.mts

@@ -0,0 +1,9 @@
+import { Value, ReferenceRecord } from '../value.mts';
+import { type ReferenceEvaluator } from '../evaluator.mts';
+import { type PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-evaluate-expression-key-property-access */
+export declare function EvaluatePropertyAccessWithExpressionKey(baseValue: Value, expression: ParseNode.Expression, strict: boolean): ReferenceEvaluator;
+/** https://tc39.es/ecma262/#sec-evaluate-identifier-key-property-access */
+export declare function EvaluatePropertyAccessWithIdentifierKey(baseValue: Value, identifierName: ParseNode.IdentifierName, strict: boolean): PlainCompletion<ReferenceRecord>;
+//# sourceMappingURL=EvaluatePropertyAccess.d.mts.map

package/declaration/runtime-semantics/EvaluatePropertyAccess.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluatePropertyAccess.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EvaluatePropertyAccess.mts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAY,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,EAAK,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,2EAA2E;AAC3E,wBAAiB,uCAAuC,CAAC,SAAS,EAAE,KAAK,EAAE,UAAU,EAAE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAYhJ;AAED,2EAA2E;AAC3E,wBAAgB,uCAAuC,CAAC,SAAS,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAG,eAAe,CAAC,eAAe,CAAC,CAYrK"}

package/declaration/runtime-semantics/EvaluateStringOrNumericBinaryExpression.d.mts

@@ -0,0 +1,6 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type BinaryOperator } from './all.mts';
+/** https://tc39.es/ecma262/#sec-evaluatestringornumericbinaryexpression */
+export declare function EvaluateStringOrNumericBinaryExpression(leftOperand: ParseNode.Expression, opText: BinaryOperator, rightOperand: ParseNode.Expression): ValueEvaluator;
+//# sourceMappingURL=EvaluateStringOrNumericBinaryExpression.d.mts.map

package/declaration/runtime-semantics/EvaluateStringOrNumericBinaryExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluateStringOrNumericBinaryExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/EvaluateStringOrNumericBinaryExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAEpF,2EAA2E;AAC3E,wBAAiB,uCAAuC,CAAC,WAAW,EAAE,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,YAAY,EAAE,SAAS,CAAC,UAAU,GAAG,cAAc,CAWtK"}

package/declaration/runtime-semantics/ExponentiationExpression.d.mts

@@ -0,0 +1,5 @@
+import type { ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-exp-operator-runtime-semantics-evaluation */
+export declare function Evaluate_ExponentiationExpression({ UpdateExpression, ExponentiationExpression }: ParseNode.ExponentiationExpression): ValueEvaluator;
+//# sourceMappingURL=ExponentiationExpression.d.mts.map

package/declaration/runtime-semantics/ExponentiationExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExponentiationExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ExponentiationExpression.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,6EAA6E;AAE7E,wBAAiB,iCAAiC,CAAC,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,EAAE,SAAS,CAAC,wBAAwB,GAAG,cAAc,CAGrJ"}

package/declaration/runtime-semantics/ExportDeclaration.d.mts

@@ -0,0 +1,17 @@
+import { Value } from '../value.mts';
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-exports-runtime-semantics-evaluation */
+export declare function Evaluate_ExportDeclaration(ExportDeclaration: ParseNode.ExportDeclaration): Generator<import("#self").EvaluatorYieldType, void | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").JSStringValue | import("#self").UndefinedValue | import("#self").NullValue | import("#self").BooleanValue<boolean> | import("#self").SymbolValue | import("#self").NumberValue | import("#self").BigIntValue | import("#self").ObjectValue | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").BreakCompletion | import("#self").ContinueCompletion | NormalCompletion<void | Value>, import("#self").EvaluatorNextType>;
+//# sourceMappingURL=ExportDeclaration.d.mts.map

package/declaration/runtime-semantics/ExportDeclaration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ExportDeclaration.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAIrC,OAAO,EAAE,gBAAgB,EAAK,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAQzD,wEAAwE;AASxE,wBAAiB,0BAA0B,CAAC,iBAAiB,EAAE,SAAS,CAAC,iBAAiB;;;;;;;;;;;8IAiEzF"}

package/declaration/runtime-semantics/ExpressionStatement.d.mts

@@ -0,0 +1,5 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-expression-statement-runtime-semantics-evaluation */
+export declare function Evaluate_ExpressionStatement({ Expression }: ParseNode.ExpressionStatement): ValueEvaluator;
+//# sourceMappingURL=ExpressionStatement.d.mts.map

package/declaration/runtime-semantics/ExpressionStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpressionStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ExpressionStatement.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qFAAqF;AAGrF,wBAAiB,4BAA4B,CAAC,EAAE,UAAU,EAAE,EAAE,SAAS,CAAC,mBAAmB,GAAG,cAAc,CAK3G"}

package/declaration/runtime-semantics/FunctionDeclaration.d.mts

@@ -0,0 +1,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_FunctionDeclaration(_FunctionDeclaration: ParseNode.FunctionDeclaration): NormalCompletion<undefined>;
+//# sourceMappingURL=FunctionDeclaration.d.mts.map

package/declaration/runtime-semantics/FunctionDeclaration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/FunctionDeclaration.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qFAAqF;AAIrF,wBAAgB,4BAA4B,CAAC,oBAAoB,EAAE,SAAS,CAAC,mBAAmB,+BAG/F"}

package/declaration/runtime-semantics/FunctionDeclarationInstantiation.d.mts

@@ -0,0 +1,6 @@
+import { type Arguments } from '../value.mts';
+import { type ECMAScriptFunctionObject } from '../abstract-ops/all.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-functiondeclarationinstantiation */
+export declare function FunctionDeclarationInstantiation(func: ECMAScriptFunctionObject, argumentsList: Arguments): PlainEvaluator<void>;
+//# sourceMappingURL=FunctionDeclarationInstantiation.d.mts.map

package/declaration/runtime-semantics/FunctionDeclarationInstantiation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionDeclarationInstantiation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/FunctionDeclarationInstantiation.mts"],"names":[],"mappings":"AACA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAKL,KAAK,wBAAwB,EAC9B,MAAM,yBAAyB,CAAC;AAcjC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMvD,oEAAoE;AACpE,wBAAiB,gCAAgC,CAAC,IAAI,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,cAAc,CAAC,IAAI,CAAC,CAoPhI"}

package/declaration/runtime-semantics/FunctionExpression.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_FunctionExpression(FunctionExpression: ParseNode.FunctionExpression): import("../helpers.mts").Mutable<import("../index.mts").ECMAScriptFunctionObject>;
+//# sourceMappingURL=FunctionExpression.d.mts.map

package/declaration/runtime-semantics/FunctionExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/FunctionExpression.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,qFAAqF;AAIrF,wBAAgB,2BAA2B,CAAC,kBAAkB,EAAE,SAAS,CAAC,kBAAkB,qFAG3F"}

package/declaration/runtime-semantics/FunctionStatementList.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_FunctionStatementList(FunctionStatementList: ParseNode.FunctionStatementList): Generator<import("../evaluator.mts").EvaluatorYieldType, import("../completion.mts").Completion<void | import("../value.mts").Value>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=FunctionStatementList.d.mts.map

package/declaration/runtime-semantics/FunctionStatementList.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionStatementList.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/FunctionStatementList.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,qFAAqF;AAKrF,wBAAgB,8BAA8B,CAAC,qBAAqB,EAAE,SAAS,CAAC,qBAAqB,uLAEpG"}

package/declaration/runtime-semantics/GeneratorExpression.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_GeneratorExpression(GeneratorExpression: ParseNode.GeneratorExpression): import("../helpers.mts").Mutable<import("../index.mts").ECMAScriptFunctionObject>;
+//# sourceMappingURL=GeneratorExpression.d.mts.map

package/declaration/runtime-semantics/GeneratorExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GeneratorExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/GeneratorExpression.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,+FAA+F;AAI/F,wBAAgB,4BAA4B,CAAC,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,qFAG9F"}

package/declaration/runtime-semantics/GetSubstitution.d.mts

@@ -0,0 +1,5 @@
+import { ObjectValue, UndefinedValue, JSStringValue } from '../value.mts';
+import type { ValueEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-getsubstitution */
+export declare function GetSubstitution(matched: JSStringValue, str: JSStringValue, position: number, captures: readonly (JSStringValue | UndefinedValue)[], namedCaptures: UndefinedValue | ObjectValue, replacementTemplate: JSStringValue): ValueEvaluator<JSStringValue>;
+//# sourceMappingURL=GetSubstitution.d.mts.map

package/declaration/runtime-semantics/GetSubstitution.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GetSubstitution.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/GetSubstitution.mts"],"names":[],"mappings":"AAKA,OAAO,EACL,WAAW,EAAE,cAAc,EAAE,aAAa,EAC3C,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAGvD,mDAAmD;AACnD,wBAAiB,eAAe,CAAC,OAAO,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,CAAC,aAAa,GAAG,cAAc,CAAC,EAAE,EAAE,aAAa,EAAE,cAAc,GAAG,WAAW,EAAE,mBAAmB,EAAE,aAAa,GAAG,cAAc,CAAC,aAAa,CAAC,CA4EpQ"}

package/declaration/runtime-semantics/GlobalDeclarationInstantiation.d.mts

@@ -0,0 +1,12 @@
+import { GlobalEnvironmentRecord } from '../environment.mts';
+import { Value } from '../value.mts';
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function GlobalDeclarationInstantiation(script: ParseNode.Script, env: GlobalEnvironmentRecord): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | NormalCompletion<undefined>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=GlobalDeclarationInstantiation.d.mts.map

package/declaration/runtime-semantics/GlobalDeclarationInstantiation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalDeclarationInstantiation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/GlobalDeclarationInstantiation.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAU7D,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,wBAAiB,8BAA8B,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,uBAAuB;;;;;;+EA4HrG"}

package/declaration/runtime-semantics/HoistableDeclaration.d.mts

@@ -0,0 +1,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-statement-semantics-runtime-semantics-evaluation */
+export declare function Evaluate_HoistableDeclaration(_HoistableDeclaration: ParseNode.HoistableDeclaration): NormalCompletion<undefined>;
+//# sourceMappingURL=HoistableDeclaration.d.mts.map

package/declaration/runtime-semantics/HoistableDeclaration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HoistableDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/HoistableDeclaration.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,oFAAoF;AAKpF,wBAAgB,6BAA6B,CAAC,qBAAqB,EAAE,SAAS,CAAC,oBAAoB,+BAGlG"}

package/declaration/runtime-semantics/IdentifierReference.d.mts

@@ -0,0 +1,6 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ReferenceRecord } from '../value.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-identifiers-runtime-semantics-evaluation */
+export declare function Evaluate_IdentifierReference(IdentifierReference: ParseNode.IdentifierReference): PlainEvaluator<ReferenceRecord>;
+//# sourceMappingURL=IdentifierReference.d.mts.map

package/declaration/runtime-semantics/IdentifierReference.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdentifierReference.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/IdentifierReference.mts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,4EAA4E;AAK5E,wBAAiB,4BAA4B,CAAC,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,GAAG,cAAc,CAAC,eAAe,CAAC,CAGjI"}

package/declaration/runtime-semantics/IfStatement.d.mts

@@ -0,0 +1,17 @@
+import { NormalCompletion } from '../completion.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-if-statement-runtime-semantics-evaluation */
+export declare function Evaluate_IfStatement({ Expression, Statement_a, Statement_b }: ParseNode.IfStatement): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../index.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../index.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | NormalCompletion<void | Value>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=IfStatement.d.mts.map

package/declaration/runtime-semantics/IfStatement.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IfStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/IfStatement.mts"],"names":[],"mappings":"AAKA,OAAO,EAGL,gBAAgB,EAGjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,6EAA6E;AAI7E,wBAAiB,oBAAoB,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,SAAS,CAAC,WAAW;;;;;;;;;;;iLA6BpG"}

package/declaration/runtime-semantics/ImportCall.d.mts

@@ -0,0 +1,6 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import { type PromiseObject } from '../index.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-import-calls */
+export declare function Evaluate_ImportCall(ImportCall: ParseNode.ImportCall): ValueEvaluator<PromiseObject>;
+//# sourceMappingURL=ImportCall.d.mts.map

package/declaration/runtime-semantics/ImportCall.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportCall.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ImportCall.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAUjE,OAAO,EACsL,KAAK,aAAa,EAC9M,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,gDAAgD;AAEhD,wBAAiB,mBAAmB,CAAC,UAAU,EAAE,SAAS,CAAC,UAAU,GAAG,cAAc,CAAC,aAAa,CAAC,CAGpG"}

package/declaration/runtime-semantics/ImportDeclaration.d.mts

@@ -0,0 +1,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-module-semantics-runtime-semantics-evaluation */
+export declare function Evaluate_ImportDeclaration(_ImportDeclaration: ParseNode.ImportDeclaration): NormalCompletion<undefined>;
+//# sourceMappingURL=ImportDeclaration.d.mts.map

package/declaration/runtime-semantics/ImportDeclaration.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ImportDeclaration.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,iFAAiF;AAEjF,wBAAgB,0BAA0B,CAAC,kBAAkB,EAAE,SAAS,CAAC,iBAAiB,+BAGzF"}

package/declaration/runtime-semantics/ImportMeta.d.mts

@@ -0,0 +1,5 @@
+import { ObjectValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-meta-properties */
+export declare function Evaluate_ImportMeta(_ImportMeta: ParseNode.ImportMeta): ObjectValue;
+//# sourceMappingURL=ImportMeta.d.mts.map

package/declaration/runtime-semantics/ImportMeta.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ImportMeta.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ImportMeta.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAS,MAAM,cAAc,CAAC;AASlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,mDAAmD;AAEnD,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,SAAS,CAAC,UAAU,eA8BpE"}

package/declaration/runtime-semantics/InstantiateArrowFunctionExpression.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PrivateName, PropertyKeyValue } from '#self';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiatearrowfunctionexpression */
+export declare function InstantiateArrowFunctionExpression(ArrowFunction: ParseNode.ArrowFunction, name?: PropertyKeyValue | PrivateName): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateArrowFunctionExpression.d.mts.map

package/declaration/runtime-semantics/InstantiateArrowFunctionExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateArrowFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateArrowFunctionExpression.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAE3D,wFAAwF;AAExF,wBAAgB,kCAAkC,CAAC,aAAa,EAAE,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEA0B/H"}

package/declaration/runtime-semantics/InstantiateAsyncArrowFunctionExpression.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PrivateName, PropertyKeyValue } from '#self';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncarrowfunctionexpression */
+export declare function InstantiateAsyncArrowFunctionExpression(AsyncArrowFunction: ParseNode.AsyncArrowFunction, name?: PropertyKeyValue | PrivateName): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateAsyncArrowFunctionExpression.d.mts.map

package/declaration/runtime-semantics/InstantiateAsyncArrowFunctionExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateAsyncArrowFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateAsyncArrowFunctionExpression.mts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAE3D,6FAA6F;AAE7F,wBAAgB,uCAAuC,CAAC,kBAAkB,EAAE,SAAS,CAAC,kBAAkB,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEA4B9I"}

package/declaration/runtime-semantics/InstantiateAsyncFunctionExpression.d.mts

@@ -0,0 +1,5 @@
+import { PrivateName, type PropertyKeyValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-instantiateasyncfunctionexpression */
+export declare function InstantiateAsyncFunctionExpression(AsyncFunctionExpression: ParseNode.AsyncFunctionExpression, name?: PropertyKeyValue | PrivateName): import("../helpers.mts").Mutable<import("../abstract-ops/function-operations.mts").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateAsyncFunctionExpression.d.mts.map