@engine262/engine262 0.0.1-01e9fa95a4e8a1c042efd00492309a2de4998fd0

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

@@ -0,0 +1,37 @@
+import { Value, type Arguments } from '../value.mts';
+import { type StatementEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type ECMAScriptFunctionObject, type Body } from '#self';
+export declare function Evaluate_AnyFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody | ParseNode.AsyncBody | ParseNode.GeneratorBody | ParseNode.AsyncGeneratorBody): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluatefunctionbody */
+export declare function EvaluateFunctionBody({ FunctionStatementList }: ParseNode.FunctionBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** 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-runtime-semantics-evaluateconcisebody */
+export declare function EvaluateConciseBody({ ExpressionBody }: ParseNode.ConciseBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("#self").EvaluatorYieldType, void | import("#self").BigIntValue | import("#self").BooleanValue<boolean> | import("#self").BreakCompletion | import("#self").ContinueCompletion | import("#self").JSStringValue | import("#self").NormalCompletion<void | Value> | import("#self").NullValue | import("#self").NumberValue | import("#self").ObjectValue | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").SymbolValue | import("#self").ThrowCompletion<Value> | import("#self").UndefinedValue, import("#self").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluategeneratorbody */
+export declare function EvaluateGeneratorBody(GeneratorBody: ParseNode.GeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncgeneratorbody */
+export declare function EvaluateAsyncGeneratorBody(FunctionBody: ParseNode.AsyncGeneratorBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateasyncfunctionbody */
+export declare function EvaluateAsyncFunctionBody(FunctionBody: ParseNode.AsyncBody, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("#self").EvaluatorYieldType, {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+}, import("#self").EvaluatorNextType>;
+export declare function EvaluateBody_AssignmentExpression(AssignmentExpression: ParseNode.Initializer, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-runtime-semantics-evaluateclassstaticblockbody */
+export declare function EvaluateClassStaticBlockBody({ ClassStaticBlockStatementList }: ParseNode.ClassStaticBlockBody, funcObject: ECMAScriptFunctionObject): StatementEvaluator;
+export declare function EvaluateBody(Body: Body, functionObject: ECMAScriptFunctionObject, argumentsList: Arguments): Generator<import("#self").EvaluatorYieldType, void | import("#self").BigIntValue | import("#self").BooleanValue<boolean> | import("#self").BreakCompletion | import("#self").ContinueCompletion | import("#self").JSStringValue | import("#self").NormalCompletion<void | Value> | import("#self").NullValue | import("#self").NumberValue | import("#self").ObjectValue | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").SymbolValue | import("#self").ThrowCompletion<Value> | import("#self").UndefinedValue, import("#self").EvaluatorNextType>;
+//# 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":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAQrD,OAAO,EAAY,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAQzD,OAAO,EASL,KAAK,wBAAwB,EAG7B,KAAK,IAAI,EACV,MAAM,OAAO,CAAC;AAEf,wBAAgB,wBAAwB,CAAC,EAAE,qBAAqB,EAAE,EAAE,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,kBAAkB,sBAExK;AAED,0EAA0E;AAE1E,wBAAiB,oBAAoB,CAAC,EAAE,qBAAqB,EAAE,EAAE,SAAS,CAAC,YAAY,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAM/K;AAED,2FAA2F;AAE3F,wBAAiB,uBAAuB,CAAC,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,cAAc,GAAG,kBAAkB,CAO/G;AAED,yEAAyE;AAEzE,wBAAiB,mBAAmB,CAAC,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,WAAW,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;8IAKjJ;AAqBD,2EAA2E;AAE3E,wBAAiB,qBAAqB,CAAC,aAAa,EAAE,SAAS,CAAC,aAAa,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAarK;AAED,gFAAgF;AAEhF,wBAAiB,0BAA0B,CAAC,YAAY,EAAE,SAAS,CAAC,kBAAkB,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAiB9K;AAED,+EAA+E;AAE/E,wBAAiB,yBAAyB,CAAC,YAAY,EAAE,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;sCAe/I;AAID,wBAAiB,iCAAiC,CAAC,oBAAoB,EAAE,SAAS,CAAC,WAAW,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS,GAAG,kBAAkB,CAyBtL;AAED,kFAAkF;AAElF,wBAAiB,4BAA4B,CAAC,EAAE,6BAA6B,EAAE,EAAE,SAAS,CAAC,oBAAoB,EAAE,UAAU,EAAE,wBAAwB,GAAG,kBAAkB,CAOzK;AASD,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,wBAAwB,EAAE,aAAa,EAAE,SAAS;;;;;8IAoB1G"}

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

@@ -0,0 +1,5 @@
+import { ObjectValue, 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.TemplateLiteral | ParseNode.Arguments, tailPosition: boolean, callExpression?: ParseNode.CallExpression | ParseNode.OptionalExpression): Generator<import("#self").EvaluatorYieldType, import("#self").BigIntValue | import("#self").BooleanValue<boolean> | import("#self").JSStringValue | import("#self").NormalCompletion<Value> | import("#self").NullValue | import("#self").NumberValue | ObjectValue | import("#self").SymbolValue | import("#self").ThrowCompletion | import("#self").UndefinedValue, import("#self").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":"AAAA,OAAO,EACL,WAAW,EAAE,KAAK,EAAE,eAAe,EACpC,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAazD,gDAAgD;AAChD,wBAAiB,YAAY,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,eAAe,GAAG,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,cAAc,CAAC,EAAE,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,kBAAkB,4YAgD9N"}

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":"AAAA,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;AAMzD,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;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAsC,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AAGpF,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,11 @@
+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 | import("#self").BigIntValue | import("#self").BooleanValue<boolean> | import("#self").BreakCompletion | import("#self").ContinueCompletion | import("#self").JSStringValue | NormalCompletion<void | Value> | import("#self").NullValue | import("#self").NumberValue | import("#self").ObjectValue | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").SymbolValue | import("#self").ThrowCompletion<Value> | import("#self").UndefinedValue, 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":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAGrC,OAAO,EAAE,gBAAgB,EAAK,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAYzD,wEAAwE;AASxE,wBAAiB,0BAA0B,CAAC,iBAAiB,EAAE,SAAS,CAAC,iBAAiB;;;;;8IAyEzF"}

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":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,qFAAqF;AAGrF,wBAAiB,4BAA4B,CAAC,EAAE,UAAU,EAAE,EAAE,SAAS,CAAC,mBAAmB,GAAG,cAAc,CAK3G"}

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

@@ -0,0 +1,7 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import type { Value } from '../value.mts';
+import type { EnvironmentRecord } from '../execution-context/Environment.mts';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-fordeclarationbindinginitialization */
+export declare function ForDeclarationBindingInitialization(declaration: ParseNode.ForDeclaration, value: Value, envRecord: EnvironmentRecord): PlainEvaluator;
+//# sourceMappingURL=ForDeclarationBindingInitialization.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ForDeclarationBindingInitialization.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ForDeclarationBindingInitialization.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAC;AAI9E,yFAAyF;AACzF,wBAAiB,mCAAmC,CAClD,WAAW,EAAE,SAAS,CAAC,cAAc,EACrC,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,iBAAiB,GAC3B,cAAc,CAQhB"}

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,+BAE/F"}

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

@@ -0,0 +1,6 @@
+import { type Arguments } from '../value.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { type ECMAScriptFunctionObject } from '#self';
+/** 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":"AAAA,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAarD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMvD,OAAO,EAKL,KAAK,wBAAwB,EAC9B,MAAM,OAAO,CAAC;AAEf,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("../index.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,mFAE3F"}

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

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type StatementEvaluator } from '#self';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-evaluation */
+export declare function Evaluate_FunctionStatementList(FunctionStatementList: ParseNode.FunctionStatementList): StatementEvaluator;
+//# 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;AAIzD,OAAO,EAA6D,KAAK,kBAAkB,EAAE,MAAM,OAAO,CAAC;AAE3G,qFAAqF;AAKrF,wBAAiB,8BAA8B,CAAC,qBAAqB,EAAE,SAAS,CAAC,qBAAqB,GAAG,kBAAkB,CAK1H"}

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

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":"AAAA,OAAO,EACL,WAAW,EAAE,cAAc,EAAE,aAAa,EAC3C,MAAM,cAAc,CAAC;AAEtB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAQvD,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,5 @@
+import { NormalCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { GlobalEnvironmentRecord } from '#self';
+export declare function GlobalDeclarationInstantiation(script: ParseNode.Script, env: GlobalEnvironmentRecord): Generator<import("#self").EvaluatorYieldType, NormalCompletion<undefined> | import("#self").ThrowCompletion, import("#self").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":"AASA,OAAO,EAAK,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAExD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAU,uBAAuB,EAAS,MAAM,OAAO,CAAC;AAE/D,wBAAiB,8BAA8B,CAAC,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,GAAG,EAAE,uBAAuB,mJA4HrG"}

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":"AACA,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;AAGvD,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,11 @@
+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("#self").EvaluatorYieldType, import("#self").BreakCompletion | import("#self").ContinueCompletion | NormalCompletion<void | Value> | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").ThrowCompletion<Value>, import("#self").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":"AACA,OAAO,EAGL,gBAAgB,EAGjB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAMzD,6EAA6E;AAI7E,wBAAiB,oBAAoB,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,EAAE,SAAS,CAAC,WAAW;;;;;+EA6BpG"}

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":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIjE,OAAO,EACkN,KAAK,aAAa,EAC1O,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAWzD,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;AAGlD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAQzD,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":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIzD,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":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAIzD,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("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateAsyncFunctionExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateAsyncFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateAsyncFunctionExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAAS,KAAK,gBAAgB,EAC1C,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAUzD,wFAAwF;AACxF,wBAAgB,kCAAkC,CAAC,uBAAuB,EAAE,SAAS,CAAC,uBAAuB,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEA0DnJ"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateAsyncGeneratorFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateAsyncGeneratorFunctionExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EACc,KAAK,gBAAgB,EAAE,WAAW,EACtD,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAYzD,iGAAiG;AAIjG,wBAAgB,2CAA2C,CAAC,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEAoE9J"}

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

@@ -0,0 +1,12 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { EnvironmentRecord, PrivateEnvironmentRecord } from '#self';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-instantiatefunctionobject */
+export declare function InstantiateFunctionObject_FunctionDeclaration(FunctionDeclaration: ParseNode.FunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | null): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+/** https://tc39.es/ecma262/#sec-generator-function-definitions-runtime-semantics-instantiatefunctionobject */
+export declare function InstantiateFunctionObject_GeneratorDeclaration(GeneratorDeclaration: ParseNode.GeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | null): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+/** https://tc39.es/ecma262/#sec-async-function-definitions-InstantiateFunctionObject */
+export declare function InstantiateFunctionObject_AsyncFunctionDeclaration(AsyncFunctionDeclaration: ParseNode.AsyncFunctionDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | null): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+/** https://tc39.es/ecma262/#sec-asyncgenerator-definitions-evaluatebody */
+export declare function InstantiateFunctionObject_AsyncGeneratorDeclaration(AsyncGeneratorDeclaration: ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | null): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+export declare function InstantiateFunctionObject(AnyFunctionDeclaration: ParseNode.FunctionDeclaration | ParseNode.GeneratorDeclaration | ParseNode.AsyncFunctionDeclaration | ParseNode.AsyncGeneratorDeclaration, env: EnvironmentRecord, privateEnv: PrivateEnvironmentRecord | null): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateFunctionObject.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateFunctionObject.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateFunctionObject.mts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAUzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,OAAO,CAAC;AAEzE,oGAAoG;AAIpG,wBAAgB,6CAA6C,CAAC,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,qEAcpL;AAED,8GAA8G;AAI9G,wBAAgB,8CAA8C,CAAC,oBAAoB,EAAE,SAAS,CAAC,oBAAoB,EAAE,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,qEAqBvL;AAED,wFAAwF;AAIxF,wBAAgB,kDAAkD,CAAC,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,EAAE,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,qEAYnM;AAED,2EAA2E;AAI3E,wBAAgB,mDAAmD,CAAC,yBAAyB,EAAE,SAAS,CAAC,yBAAyB,EAAE,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,qEAqBtM;AAED,wBAAgB,yBAAyB,CAAC,sBAAsB,EAAE,SAAS,CAAC,mBAAmB,GAAG,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,wBAAwB,GAAG,SAAS,CAAC,yBAAyB,EAAE,GAAG,EAAE,iBAAiB,EAAE,UAAU,EAAE,wBAAwB,GAAG,IAAI,qEAc/Q"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateGeneratorFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateGeneratorFunctionExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EACc,KAAK,gBAAgB,EAAE,WAAW,EACtD,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAYzD,4FAA4F;AAI5F,wBAAgB,sCAAsC,CAAC,mBAAmB,EAAE,SAAS,CAAC,mBAAmB,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEA4D/I"}

package/declaration/runtime-semantics/InstantiateOrdinaryFunctionExpression.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-instantiateordinaryfunctionexpression */
+export declare function InstantiateOrdinaryFunctionExpression(FunctionExpression: ParseNode.FunctionExpression, name?: PropertyKeyValue | PrivateName): import("#self").Mutable<import("#self").ECMAScriptFunctionObject>;
+//# sourceMappingURL=InstantiateOrdinaryFunctionExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InstantiateOrdinaryFunctionExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/InstantiateOrdinaryFunctionExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAS,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAWzD,2FAA2F;AAI3F,wBAAgB,qCAAqC,CAAC,kBAAkB,EAAE,SAAS,CAAC,kBAAkB,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,WAAW,qEA8C5I"}

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

@@ -0,0 +1,7 @@
+import { type PlainEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type IteratorRecord, UndefinedValue, type EnvironmentRecord } from '#self';
+/** https://tc39.es/ecma262/#sec-function-definitions-runtime-semantics-iteratorbindinginitialization */
+export declare function IteratorBindingInitialization_FormalParameters(FormalParameters: ParseNode.FormalParameters, iteratorRecord: IteratorRecord, environment: EnvironmentRecord | UndefinedValue): Generator<import("#self").EvaluatorYieldType, import("#self").PlainCompletion<void>, import("#self").EvaluatorNextType>;
+export declare function IteratorBindingInitialization_ArrayBindingPattern({ BindingElementList, BindingRestElement }: ParseNode.ArrayBindingPattern, iteratorRecord: IteratorRecord, environment: EnvironmentRecord | UndefinedValue): PlainEvaluator;
+//# sourceMappingURL=IteratorBindingInitialization.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"IteratorBindingInitialization.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/IteratorBindingInitialization.mts"],"names":[],"mappings":"AAKA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,OAAO,EAWL,KAAK,cAAc,EAGnB,cAAc,EAAE,KAAK,iBAAiB,EACvC,MAAM,OAAO,CAAC;AAEf,wGAAwG;AAIxG,wBAAiB,8CAA8C,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,iBAAiB,GAAG,cAAc,2HAe5L;AAmJD,wBAAiB,iDAAiD,CAAC,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,EAAE,SAAS,CAAC,mBAAmB,EAAE,cAAc,EAAE,cAAc,EAAE,WAAW,EAAE,iBAAiB,GAAG,cAAc,GAAG,cAAc,CAe7O"}

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

@@ -0,0 +1,6 @@
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { EnvironmentRecord, PropertyKeyValue, UndefinedValue } from '#self';
+/** https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization */
+export declare function KeyedBindingInitialization(node: ParseNode.BindingElement | ParseNode.SingleNameBinding, value: Value, environment: EnvironmentRecord | UndefinedValue, propertyName: PropertyKeyValue): Generator<import("#self").EvaluatorYieldType, import("#self").PlainCompletion<void>, import("#self").EvaluatorNextType>;
+//# sourceMappingURL=KeyedBindingInitialization.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KeyedBindingInitialization.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/KeyedBindingInitialization.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAIrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAYzD,OAAO,KAAK,EACV,iBAAiB,EAAuB,gBAAgB,EAAE,cAAc,EACzE,MAAM,OAAO,CAAC;AAEf,gFAAgF;AAChF,wBAAiB,0BAA0B,CAAC,IAAI,EAAE,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,iBAAiB,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,iBAAiB,GAAG,cAAc,EAAE,YAAY,EAAE,gBAAgB,2HAuCtM"}

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

@@ -0,0 +1,7 @@
+import { type PlainEvaluator, type StatementEvaluator } from '../evaluator.mts';
+import { JSStringSet } from '../utils/container.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function LabelledEvaluation(node: ParseNode.LabelledStatement | ParseNode.BreakableStatement, labelSet: JSStringSet): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-for-in-and-for-of-statements-runtime-semantics-evaluation */
+export declare function Evaluate_ForBinding({ BindingIdentifier, strict }: ParseNode.ForBinding): PlainEvaluator<import("#self").ReferenceRecord>;
+//# sourceMappingURL=LabelledEvaluation.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LabelledEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/LabelledEvaluation.mts"],"names":[],"mappings":"AAGA,OAAO,EACqB,KAAK,cAAc,EAAE,KAAK,kBAAkB,EACvE,MAAM,kBAAkB,CAAC;AAuB1B,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA0DzD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,kBAAkB,EAAE,QAAQ,EAAE,WAAW,GAAG,kBAAkB,CAe9I;AA+nBD,6FAA6F;AAE7F,wBAAgB,mBAAmB,CAAC,EAAE,iBAAiB,EAAE,MAAM,EAAE,EAAE,SAAS,CAAC,UAAU,mDAKtF"}

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

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

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

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

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

@@ -0,0 +1,14 @@
+import { type PlainEvaluator } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type DisposableResourceKind } from '../abstract-ops/disposable-operations.mts';
+/** https://tc39.es/ecma262/#sec-bindingevaluation */
+export declare function BindingEvaluation(BindingList: ParseNode.BindingList, kind: 'normal' | DisposableResourceKind): Generator<import("#self").EvaluatorYieldType, void | import("#self").BigIntValue | import("#self").BooleanValue<boolean> | import("#self").BreakCompletion | import("#self").ContinueCompletion | import("#self").JSStringValue | import("#self").NormalCompletion<void | Value> | import("#self").NullValue | import("#self").NumberValue | import("#self").ObjectValue | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("#self").GCMarker): void;
+} | import("#self").SymbolValue | import("#self").ThrowCompletion<Value> | import("#self").UndefinedValue, import("#self").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-let-and-const-declarations-runtime-semantics-evaluation */
+export declare function Evaluate_LexicalDeclaration(declaration: ParseNode.LexicalDeclaration | ParseNode.UsingDeclaration | ParseNode.AwaitUsingDeclaration): PlainEvaluator;
+//# sourceMappingURL=LexicalDeclaration.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LexicalDeclaration.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/LexicalDeclaration.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIjE,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAGrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,2CAA2C,CAAC;AA8DnD,qDAAqD;AAKrD,wBAAiB,iBAAiB,CAChC,WAAW,EAAE,SAAS,CAAC,WAAW,EAClC,IAAI,EAAE,QAAQ,GAAG,sBAAsB;;;;;8IAUxC;AAED,2FAA2F;AAE3F,wBAAiB,2BAA2B,CAC1C,WAAW,EAAE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,qBAAqB,GACvG,cAAc,CAiBhB"}

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

@@ -0,0 +1,6 @@
+import { Value } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { NormalCompletion } from '../completion.mts';
+/** https://tc39.es/ecma262/#sec-literals-runtime-semantics-evaluation */
+export declare function Evaluate_Literal(Literal: ParseNode.Literal): NormalCompletion<Value>;
+//# sourceMappingURL=Literal.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Literal.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/Literal.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAGrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,yEAAyE;AAMzE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAuBpF"}

package/declaration/runtime-semantics/LogicalANDExpression.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_LogicalANDExpression({ LogicalANDExpression, BitwiseORExpression }: ParseNode.LogicalANDExpression): ValueEvaluator;
+//# sourceMappingURL=LogicalANDExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LogicalANDExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/LogicalANDExpression.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,yFAAyF;AAGzF,wBAAiB,6BAA6B,CAAC,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,EAAE,SAAS,CAAC,oBAAoB,GAAG,cAAc,CAe5I"}

package/declaration/runtime-semantics/LogicalORExpression.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_LogicalORExpression({ LogicalORExpression, LogicalANDExpression }: ParseNode.LogicalORExpression): ValueEvaluator;
+//# sourceMappingURL=LogicalORExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LogicalORExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/LogicalORExpression.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,yFAAyF;AAGzF,wBAAiB,4BAA4B,CAAC,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,mBAAmB,GAAG,cAAc,CAe1I"}

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

@@ -0,0 +1,3 @@
+/** https://tc39.es/ecma262/#sec-runtime-semantics-mv-s */
+export declare function MV_StringNumericLiteral(StringNumericLiteral: string): import("#self").NumberValue;
+//# sourceMappingURL=MV.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MV.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/MV.mts"],"names":[],"mappings":"AAEA,0DAA0D;AAK1D,wBAAgB,uBAAuB,CAAC,oBAAoB,EAAE,MAAM,+BAEnE"}

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

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator, ReferenceRecord } from '#self';
+/** https://tc39.es/ecma262/#sec-property-accessors-runtime-semantics-evaluation */
+export declare function Evaluate_MemberExpression(MemberExpression: ParseNode.MemberExpression): PlainEvaluator<ReferenceRecord>;
+//# sourceMappingURL=MemberExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemberExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/MemberExpression.mts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAMzD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,OAAO,CAAC;AA0C7D,mFAAmF;AAOnF,wBAAgB,yBAAyB,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,mCAWrF"}

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

@@ -0,0 +1,28 @@
+import { Value, PrivateName, UndefinedValue, ObjectValue, BooleanValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import type { PlainEvaluator } from '../evaluator.mts';
+import { ClassElementDefinitionRecord } from './all.mts';
+import { type FunctionObject } from '#self';
+/** https://tc39.es/ecma262/#sec-privateelement-specification-type */
+export interface PrivateElementRecord_Value {
+    readonly Key: PrivateName;
+    readonly Kind: 'method' | 'field';
+    Value?: Value;
+    readonly Getter?: undefined;
+    readonly Setter?: undefined;
+}
+export interface PrivateElementRecord_Accessor {
+    readonly Key: PrivateName;
+    readonly Kind: 'accessor';
+    Value?: Value;
+    readonly Getter?: FunctionObject | UndefinedValue;
+    readonly Setter?: FunctionObject | UndefinedValue;
+}
+export type PrivateElementRecord = PrivateElementRecord_Value | PrivateElementRecord_Accessor;
+export declare const PrivateElementRecord: {
+    (value: PrivateElementRecord): PrivateElementRecord;
+    [Symbol.hasInstance](instance: unknown): instance is PrivateElementRecord;
+};
+export declare function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue, enumerable: BooleanValue): PlainEvaluator<PrivateElementRecord | void>;
+export declare function MethodDefinitionEvaluation(node: ParseNode.MethodDefinitionLike, object: ObjectValue): PlainEvaluator<ClassElementDefinitionRecord>;
+//# sourceMappingURL=MethodDefinitionEvaluation.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodDefinitionEvaluation.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/MethodDefinitionEvaluation.mts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAAc,WAAW,EAAE,cAAc,EAAyB,WAAW,EAAE,YAAY,EACjG,MAAM,cAAc,CAAC;AAKtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,4BAA4B,EAAuC,MAAM,WAAW,CAAC;AAE9F,OAAO,EAOL,KAAK,cAAc,EAEpB,MAAM,OAAO,CAAC;AAEf,qEAAqE;AACrE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC;IAClC,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC;CAC7B;AACD,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,GAAG,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAC1B,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,cAAc,CAAC;IAClD,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,GAAG,cAAc,CAAC;CACnD;AACD,MAAM,MAAM,oBAAoB,GAAG,0BAA0B,GAAG,6BAA6B,CAAC;AAC9F,eAAO,MAAM,oBAAoB,EAG5B;IACH,CAAC,KAAK,EAAE,oBAAoB,GAAG,oBAAoB,CAAC;IACpD,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE,OAAO,GAAG,QAAQ,IAAI,oBAAoB,CAAC;CAC3E,CAAC;AAgSF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,CAAC,oBAAoB,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,GAAG,cAAc,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAA;AAE5K,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,SAAS,CAAC,oBAAoB,EAAE,MAAM,EAAE,WAAW,GAAG,cAAc,CAAC,4BAA4B,CAAC,CAAA"}

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

@@ -0,0 +1,11 @@
+import { Value } from '../value.mts';
+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_Module({ ModuleBody }: ParseNode.Module): Generator<import("../evaluator.mts").EvaluatorYieldType, void | import("../value.mts").BigIntValue | import("../value.mts").BooleanValue<boolean> | import("../completion.mts").BreakCompletion | import("../completion.mts").ContinueCompletion | import("../value.mts").JSStringValue | NormalCompletion<void | Value> | import("../value.mts").NullValue | import("../value.mts").NumberValue | import("../value.mts").ObjectValue | {
+    readonly Type: 'return';
+    readonly Value: Value;
+    readonly Target: undefined;
+    mark(m: import("../index.mts").GCMarker): void;
+} | import("../value.mts").SymbolValue | import("../completion.mts").ThrowCompletion<Value> | import("../value.mts").UndefinedValue, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=Module.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Module.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/Module.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,iFAAiF;AAIjF,wBAAiB,eAAe,CAAC,EAAE,UAAU,EAAE,EAAE,SAAS,CAAC,MAAM;;;;;mLAKhE"}