@engine262/engine262 0.0.1-07c72085c73f960bcf0aa06db807321f3b446518

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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,+EAA+E;AAI/E,wBAAiB,uBAAuB,CAAC,cAAc,EAAE,SAAS,CAAC,cAAc,GAAG,mBAAmB,CAwCtG"}

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

@@ -0,0 +1,8 @@
+import { type PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator, ExpressionEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-bindingclassdeclarationevaluation */
+export declare function BindingClassDeclarationEvaluation(ClassDeclaration: ParseNode.ClassDeclaration): ExpressionEvaluator;
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_ClassDeclaration(ClassDeclaration: ParseNode.ClassDeclaration): Evaluator<PlainCompletion<void>>;
+//# 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,EAAuB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGvE,uFAAuF;AAIvF,wBAAiB,iCAAiC,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,GAAG,mBAAmB,CAsBpH;AAED,kFAAkF;AAElF,wBAAiB,yBAAyB,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAKzH"}

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

@@ -0,0 +1,12 @@
+import { Value, PrivateName, JSStringValue, UndefinedValue, type PropertyKeyValue } from '../value.mts';
+import { type ECMAScriptFunctionObject } from '../abstract-ops/all.mts';
+import { type Mutable } from '../helpers.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function ClassDefinitionEvaluation(ClassTail: ParseNode.ClassTail, classBinding: JSStringValue | UndefinedValue, className: PropertyKeyValue | PrivateName): Generator<Value, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | Mutable<ECMAScriptFunctionObject>, unknown>;
+//# 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,EAE9B,MAAM,yBAAyB,CAAC;AAgBjC,OAAO,EAA2B,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA4BzD,wBAAiB,yBAAyB,CAAC,SAAS,EAAE,SAAS,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,GAAG,cAAc,EAAE,SAAS,EAAE,gBAAgB,GAAG,WAAW;;;;;;gDA2QjK"}

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

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ExpressionEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-class-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_ClassExpression(ClassExpression: ParseNode.ClassExpression): ExpressionEvaluator;
+//# 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":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAG5D,kFAAkF;AAIlF,wBAAiB,wBAAwB,CAAC,eAAe,EAAE,SAAS,CAAC,eAAe,GAAG,mBAAmB,CAkBzG"}

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

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator } from '../evaluator.mts';
+import type { ECMAScriptFunctionObject, ObjectValue, PlainCompletion, 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): Evaluator<PlainCompletion<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,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EACV,wBAAwB,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,gBAAgB,EACtF,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,SAAS,CAAC,eAAe,CAAC,0BAA0B,CAAC,CAAC,CAuC3K"}

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 ExpressionEvaluator } 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): ExpressionEvaluator;
+//# 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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,yFAAyF;AAGzF,wBAAiB,2BAA2B,CAAC,EAAE,sBAAsB,EAAE,mBAAmB,EAAE,EAAE,SAAS,CAAC,kBAAkB,GAAG,mBAAmB,CAc/I"}

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

@@ -0,0 +1,5 @@
+import { type ExpressionEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-comma-operator-runtime-semantics-evaluation */
+export declare function Evaluate_CommaOperator({ ExpressionList }: ParseNode.CommaOperator): ExpressionEvaluator;
+//# 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":"AAAA,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,+EAA+E;AAI/E,wBAAiB,sBAAsB,CAAC,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,aAAa,GAAG,mBAAmB,CAOxG"}

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

@@ -0,0 +1,5 @@
+import { type ExpressionEvaluator } 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): ExpressionEvaluator;
+//# 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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,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,mBAAmB,CAiBvD"}

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): {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../helpers.mts").Mutable<import("../abstract-ops/function-operations.mts").ECMAScriptFunctionObject>;
+//# 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,wBAAgB,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;;;;;;iHAqKxL"}

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

@@ -0,0 +1,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-debugger-statement-runtime-semantics-evaluation */
+export declare function Evaluate_DebuggerStatement(_node: ParseNode.DebuggerStatement): NormalCompletion<undefined>;
+//# 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":"AACA,OAAO,EAAE,gBAAgB,EAAoB,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,mFAAmF;AAEnF,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,SAAS,CAAC,iBAAiB,+BAa5E"}

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

@@ -0,0 +1,10 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { Evaluator } from '../evaluator.mts';
+import type { ECMAScriptFunctionObject, ObjectValue, PlainCompletion, 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): Evaluator<PlainCompletion<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,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EACV,wBAAwB,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,gBAAgB,EACtF,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,SAAS,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CA0BhL"}

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,EAA4B,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAYrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAoQzD,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,5 @@
+import { Value } from '../value.mts';
+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<Value, import("../completion.mts").ExpressionCompletion<import("../value.mts").BooleanValue<boolean>>, unknown>;
+//# 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":"AAOA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAErC,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,6HA2ChI"}

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

@@ -0,0 +1,69 @@
+import { Value, type Arguments } from '../value.mts';
+import { type ECMAScriptFunctionObject, type Body } from '../abstract-ops/all.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<Value, void | Value | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | Value>, unknown>;
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluatebody */
+export declare function EvaluateBody_FunctionBody({ FunctionStatementList }: ParseNode.FunctionBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<Value, void | Value | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | Value>, unknown>;
+/** 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<Value, void | Value | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | Value>, unknown>;
+/** 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<Value, {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+}, unknown>;
+export declare function EvaluateBody_AssignmentExpression(AssignmentExpression: ParseNode.Initializer, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+export declare function EvaluateBody(Body: Body, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<Value, void | Value | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | Value>, unknown>;
+//# 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;AAOjC,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;;;;;;;;;;;wKAExK;AAED,uFAAuF;AAEvF,wBAAiB,yBAAyB,CAAC,EAAE,qBAAqB,EAAE,EAAE,SAAS,CAAC,YAAY,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;;;;;;;wKAK/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;;;;;;;;;;;wKAKtJ;AAqBD,iGAAiG;AAEjG,wBAAiB,0BAA0B,CAAC,aAAa,EAAE,SAAS,CAAC,aAAa,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAW1K;AAED,2EAA2E;AAE3E,wBAAiB,+BAA+B,CAAC,YAAY,EAAE,SAAS,CAAC,kBAAkB,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAgBnL;AAED,2EAA2E;AAE3E,wBAAiB,8BAA8B,CAAC,YAAY,EAAE,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;YAepJ;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;;;;;;;;;;;wKAmB1G"}

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

@@ -0,0 +1,11 @@
+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<Value, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").NormalCompletion<Value>, unknown>;
+//# 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;;;;;;kEA4CpI"}

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

@@ -0,0 +1,9 @@
+import { Value, ReferenceRecord } from '../value.mts';
+import { type ExpressionEvaluator } 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): ExpressionEvaluator<ReferenceRecord>;
+/** 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":"AAMA,OAAO,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAY,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEtE,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,mBAAmB,CAAC,eAAe,CAAC,CAgBlK;AAED,2EAA2E;AAC3E,wBAAgB,uCAAuC,CAAC,SAAS,EAAE,KAAK,EAAE,cAAc,EAAE,SAAS,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,GAAG,eAAe,CAAC,eAAe,CAAC,CAcrK"}

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

@@ -0,0 +1,6 @@
+import { type ExpressionEvaluator } 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): ExpressionEvaluator;
+//# 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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAGtE,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,mBAAmB,CAW3K"}

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

@@ -0,0 +1,5 @@
+import type { ExpressionEvaluator } 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): ExpressionEvaluator;
+//# 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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,6EAA6E;AAE7E,wBAAiB,iCAAiC,CAAC,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,EAAE,SAAS,CAAC,wBAAwB,GAAG,mBAAmB,CAG1J"}

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<Value, void | Value | {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("#self").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").BreakCompletion | import("#self").ContinueCompletion | NormalCompletion<void | Value>, unknown>;
+//# 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;;;;;;;;;;;oHAiEzF"}

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

@@ -0,0 +1,5 @@
+import { type ExpressionEvaluator } 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): ExpressionEvaluator;
+//# 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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAEtE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,qFAAqF;AAGrF,wBAAiB,4BAA4B,CAAC,EAAE,UAAU,EAAE,EAAE,SAAS,CAAC,mBAAmB,GAAG,mBAAmB,CAKhH"}

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 { StatementEvaluator } from '../evaluator.mts';
+/** https://tc39.es/ecma262/#sec-functiondeclarationinstantiation */
+export declare function FunctionDeclarationInstantiation(func: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+//# 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,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAM3D,oEAAoE;AACpE,wBAAiB,gCAAgC,CAAC,IAAI,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAkP9H"}

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("../api.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,mFAG3F"}

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

@@ -0,0 +1,15 @@
+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("../value.mts").Value, void | import("../value.mts").Value | {
+    readonly Type: "throw";
+    readonly Value: import("../value.mts").Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: import("../value.mts").Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../completion.mts").NormalCompletion<void | import("../value.mts").Value>, unknown>;
+//# 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;;;;;;;;;;;+LAEpG"}

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("../api.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,mFAG9F"}

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

@@ -0,0 +1,5 @@
+import { ObjectValue, UndefinedValue, JSStringValue } from '../value.mts';
+import { type ExpressionCompletion } from '../completion.mts';
+/** https://tc39.es/ecma262/#sec-getsubstitution */
+export declare function GetSubstitution(matched: JSStringValue, str: JSStringValue, position: number, captures: readonly (JSStringValue | UndefinedValue)[], namedCaptures: UndefinedValue | ObjectValue, replacement: JSStringValue): ExpressionCompletion<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":"AAMA,OAAO,EACL,WAAW,EAAE,cAAc,EAAE,aAAa,EAC3C,MAAM,cAAc,CAAC;AACtB,OAAO,EAAK,KAAK,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAEjE,mDAAmD;AACnD,wBAAgB,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,WAAW,EAAE,aAAa,GAAG,oBAAoB,CAAC,aAAa,CAAC,CA0GjQ"}

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): {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | NormalCompletion<undefined>;
+//# 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,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,uBAAuB;;;;;;gCAgIpG"}

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 PlainCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { ReferenceRecord } from '../value.mts';
+/** https://tc39.es/ecma262/#sec-identifiers-runtime-semantics-evaluation */
+export declare function Evaluate_IdentifierReference(IdentifierReference: ParseNode.IdentifierReference): PlainCompletion<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,EAAE,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAEpD,4EAA4E;AAK5E,wBAAgB,4BAA4B,CAAC,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,GAAG,eAAe,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<Value, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | {
+    readonly Type: "return";
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../engine.mts").GCMarker): void;
+} | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | NormalCompletion<void | Value>, unknown>;
+//# 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;;;;;;;;;;;4IA6BpG"}

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

@@ -0,0 +1,6 @@
+import { type ExpressionEvaluator } from '../evaluator.mts';
+import { type PromiseObject } from '../api.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-import-calls */
+export declare function Evaluate_ImportCall({ AssignmentExpression }: ParseNode.ImportCall): ExpressionEvaluator<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,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAUtE,OAAO,EACsE,KAAK,aAAa,EAC9F,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,gDAAgD;AAEhD,wBAAiB,mBAAmB,CAAC,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,UAAU,GAAG,mBAAmB,CAAC,aAAa,CAAC,CAuBvH"}

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("../helpers.mts").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,8EA0B/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("../helpers.mts").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,8EA4B9I"}

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