@engine262/engine262 0.0.1-0574c6b92a2925de851f895445b7cfd7e97cc0ba

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

@@ -0,0 +1,9 @@
+import { type StatementEvaluator } from '../evaluator.mts';
+import { Value } from '../value.mts';
+import { Completion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-switch-statement-runtime-semantics-evaluation */
+export declare function Evaluate_SwitchStatement({ Expression, CaseBlock }: ParseNode.SwitchStatement): StatementEvaluator;
+/** https://tc39.es/ecma262/#sec-switch-statement-runtime-semantics-evaluation */
+export declare function Evaluate_CaseClause({ StatementList }: ParseNode.CaseClause | ParseNode.DefaultClause): Generator<import("../evaluator.mts").EvaluatorYieldType, Completion<void | Value>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=SwitchStatement.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SwitchStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/SwitchStatement.mts"],"names":[],"mappings":"AACA,OAAO,EAAY,KAAK,kBAAkB,EAAuB,MAAM,kBAAkB,CAAC;AAG1F,OAAO,EAC0B,KAAK,EACrC,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,UAAU,EAMX,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAsKzD,iFAAiF;AAGjF,wBAAiB,wBAAwB,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,SAAS,CAAC,eAAe,GAAG,kBAAkB,CAmBlH;AAED,iFAAiF;AAOjF,wBAAiB,mBAAmB,CAAC,EAAE,aAAa,EAAE,EAAE,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,aAAa,oIAOrG"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"TaggedTemplateExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/TaggedTemplateExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAIjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,iFAAiF;AAGjF,wBAAiB,iCAAiC,CAAC,IAAI,EAAE,SAAS,CAAC,wBAAwB,GAAG,cAAc,CAY3G"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateLiteral.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/TemplateLiteral.mts"],"names":[],"mappings":"AAGA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,kFAAkF;AAUlF,wBAAiB,wBAAwB,CAAC,EAAE,gBAAgB,EAAE,cAAc,EAAE,EAAE,SAAS,CAAC,eAAe,GAAG,cAAc,CAgBzH"}

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

@@ -0,0 +1,5 @@
+import { type ValueCompletion } from '../completion.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-this-keyword-runtime-semantics-evaluation */
+export declare function Evaluate_This(_PrimaryExpression: ParseNode.ThisExpression): ValueCompletion;
+//# sourceMappingURL=This.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"This.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/This.mts"],"names":[],"mappings":"AACA,OAAO,EAAK,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,6EAA6E;AAE7E,wBAAgB,aAAa,CAAC,kBAAkB,EAAE,SAAS,CAAC,cAAc,GAAG,eAAe,CAE3F"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ThrowStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/ThrowStatement.mts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,gFAAgF;AAEhF,wBAAiB,uBAAuB,CAAC,EAAE,UAAU,EAAE,EAAE,SAAS,CAAC,cAAc;;;;;;iDAOhF"}

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

@@ -0,0 +1,5 @@
+import { JSStringValue, Value } from '../value.mts';
+import { type ValueEvaluator } from '../completion.mts';
+/** https://tc39.es/ecma262/#sec-trimstring */
+export declare function TrimString(string: Value, where: 'start' | 'end' | 'start+end'): ValueEvaluator<JSStringValue>;
+//# sourceMappingURL=TrimString.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TrimString.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/TrimString.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAK,KAAK,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAE3D,8CAA8C;AAC9C,wBAAiB,UAAU,CAAC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,GAAG,KAAK,GAAG,WAAW,GAAG,cAAc,CAAC,aAAa,CAAC,CAa9G"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"TryStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/TryStatement.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAYrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,8EAA8E;AAK9E,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,SAAS,CAAC,YAAY;;;;;;;;;;;6MAWzE"}

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

@@ -0,0 +1,10 @@
+import { Value, UndefinedValue, BigIntValue, BooleanValue, JSStringValue, NullValue, NumberValue, ObjectValue, SymbolValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function Evaluate_UnaryExpression(UnaryExpression: ParseNode.UnaryExpression): Generator<import("../evaluator.mts").EvaluatorYieldType, {
+    readonly Type: "throw";
+    readonly Value: Value;
+    readonly Target: undefined;
+    readonly stack: Error | undefined;
+    mark(m: import("../host-defined/engine.mts").GCMarker): void;
+} | JSStringValue | UndefinedValue | NullValue | BooleanValue<boolean> | SymbolValue | NumberValue | BigIntValue | ObjectValue | import("../completion.mts").NormalCompletion<Value>, import("../evaluator.mts").EvaluatorNextType>;
+//# sourceMappingURL=UnaryExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UnaryExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/UnaryExpression.mts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,EAAmB,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,WAAW,EACnI,MAAM,cAAc,CAAC;AAGtB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA4KzD,wBAAiB,wBAAwB,CAAC,eAAe,EAAE,SAAS,CAAC,eAAe;;;;;;oOAqBnF"}

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

@@ -0,0 +1,161 @@
+import { type RegExpRecord } from '#self';
+export declare const isLeadingSurrogate: (cp: number) => boolean;
+export declare const isTrailingSurrogate: (cp: number) => boolean;
+/** https://tc39.es/ecma262/#table-nonbinary-unicode-properties */
+export declare const Table69_NonbinaryUnicodeProperties: {
+    readonly General_Category: "General_Category";
+    readonly gc: "General_Category";
+    readonly Script: "Script";
+    readonly sc: "Script";
+    readonly Script_Extensions: "Script_Extensions";
+    readonly scx: "Script_Extensions";
+};
+export type Table69_NonbinaryUnicodePropertiesCanonicalized = typeof Table69_NonbinaryUnicodeProperties[keyof typeof Table69_NonbinaryUnicodeProperties];
+/** https://tc39.es/ecma262/#table-binary-unicode-properties */
+export declare const Table70_BinaryUnicodeProperties: {
+    readonly ASCII: "ASCII";
+    readonly ASCII_Hex_Digit: "ASCII_Hex_Digit";
+    readonly AHex: "ASCII_Hex_Digit";
+    readonly Alphabetic: "Alphabetic";
+    readonly Alpha: "Alphabetic";
+    readonly Any: "Any";
+    readonly Assigned: "Assigned";
+    readonly Bidi_Control: "Bidi_Control";
+    readonly Bidi_C: "Bidi_Control";
+    readonly Bidi_Mirrored: "Bidi_Mirrored";
+    readonly Bidi_M: "Bidi_Mirrored";
+    readonly Case_Ignorable: "Case_Ignorable";
+    readonly CI: "Case_Ignorable";
+    readonly Cased: "Cased";
+    readonly Changes_When_Casefolded: "Changes_When_Casefolded";
+    readonly CWCF: "Changes_When_Casefolded";
+    readonly Changes_When_Casemapped: "Changes_When_Casemapped";
+    readonly CWCM: "Changes_When_Casemapped";
+    readonly Changes_When_Lowercased: "Changes_When_Lowercased";
+    readonly CWL: "Changes_When_Lowercased";
+    readonly Changes_When_NFKC_Casefolded: "Changes_When_NFKC_Casefolded";
+    readonly CWKCF: "Changes_When_NFKC_Casefolded";
+    readonly Changes_When_Titlecased: "Changes_When_Titlecased";
+    readonly CWT: "Changes_When_Titlecased";
+    readonly Changes_When_Uppercased: "Changes_When_Uppercased";
+    readonly CWU: "Changes_When_Uppercased";
+    readonly Dash: "Dash";
+    readonly Default_Ignorable_Code_Point: "Default_Ignorable_Code_Point";
+    readonly DI: "Default_Ignorable_Code_Point";
+    readonly Deprecated: "Deprecated";
+    readonly Dep: "Deprecated";
+    readonly Diacritic: "Diacritic";
+    readonly Dia: "Diacritic";
+    readonly Emoji: "Emoji";
+    readonly Emoji_Component: "Emoji_Component";
+    readonly EComp: "Emoji_Component";
+    readonly Emoji_Modifier: "Emoji_Modifier";
+    readonly EMod: "Emoji_Modifier";
+    readonly Emoji_Modifier_Base: "Emoji_Modifier_Base";
+    readonly EBase: "Emoji_Modifier_Base";
+    readonly Emoji_Presentation: "Emoji_Presentation";
+    readonly EPres: "Emoji_Presentation";
+    readonly Extended_Pictographic: "Extended_Pictographic";
+    readonly ExtPict: "Extended_Pictographic";
+    readonly Extender: "Extender";
+    readonly Ext: "Extender";
+    readonly Grapheme_Base: "Grapheme_Base";
+    readonly Gr_Base: "Grapheme_Base";
+    readonly Grapheme_Extend: "Grapheme_Extend";
+    readonly Gr_Ext: "Grapheme_Extend";
+    readonly Hex_Digit: "Hex_Digit";
+    readonly Hex: "Hex_Digit";
+    readonly IDS_Binary_Operator: "IDS_Binary_Operator";
+    readonly IDSB: "IDS_Binary_Operator";
+    readonly IDS_Trinary_Operator: "IDS_Trinary_Operator";
+    readonly IDST: "IDS_Trinary_Operator";
+    readonly ID_Continue: "ID_Continue";
+    readonly IDC: "ID_Continue";
+    readonly ID_Start: "ID_Start";
+    readonly IDS: "ID_Start";
+    readonly Ideographic: "Ideographic";
+    readonly Ideo: "Ideographic";
+    readonly Join_Control: "Join_Control";
+    readonly Join_C: "Join_Control";
+    readonly Logical_Order_Exception: "Logical_Order_Exception";
+    readonly LOE: "Logical_Order_Exception";
+    readonly Lowercase: "Lowercase";
+    readonly Lower: "Lowercase";
+    readonly Math: "Math";
+    readonly Noncharacter_Code_Point: "Noncharacter_Code_Point";
+    readonly NChar: "Noncharacter_Code_Point";
+    readonly Pattern_Syntax: "Pattern_Syntax";
+    readonly Pat_Syn: "Pattern_Syntax";
+    readonly Pattern_White_Space: "Pattern_White_Space";
+    readonly Pat_WS: "Pattern_White_Space";
+    readonly Quotation_Mark: "Quotation_Mark";
+    readonly QMark: "Quotation_Mark";
+    readonly Radical: "Radical";
+    readonly Regional_Indicator: "Regional_Indicator";
+    readonly RI: "Regional_Indicator";
+    readonly Sentence_Terminal: "Sentence_Terminal";
+    readonly STerm: "Sentence_Terminal";
+    readonly Soft_Dotted: "Soft_Dotted";
+    readonly SD: "Soft_Dotted";
+    readonly Terminal_Punctuation: "Terminal_Punctuation";
+    readonly Term: "Terminal_Punctuation";
+    readonly Unified_Ideograph: "Unified_Ideograph";
+    readonly UIdeo: "Unified_Ideograph";
+    readonly Uppercase: "Uppercase";
+    readonly Upper: "Uppercase";
+    readonly Variation_Selector: "Variation_Selector";
+    readonly VS: "Variation_Selector";
+    readonly White_Space: "White_Space";
+    readonly space: "White_Space";
+    readonly XID_Continue: "XID_Continue";
+    readonly XIDC: "XID_Continue";
+    readonly XID_Start: "XID_Start";
+    readonly XIDS: "XID_Start";
+};
+/** https://tc39.es/ecma262/#table-binary-unicode-properties-of-strings */
+export declare const Table71_BinaryPropertyOfStrings: {
+    readonly Basic_Emoji: "Basic_Emoji";
+    readonly Emoji_Keycap_Sequence: "Emoji_Keycap_Sequence";
+    readonly RGI_Emoji_Modifier_Sequence: "RGI_Emoji_Modifier_Sequence";
+    readonly RGI_Emoji_Flag_Sequence: "RGI_Emoji_Flag_Sequence";
+    readonly RGI_Emoji_Tag_Sequence: "RGI_Emoji_Tag_Sequence";
+    readonly RGI_Emoji_ZWJ_Sequence: "RGI_Emoji_ZWJ_Sequence";
+    readonly RGI_Emoji: "RGI_Emoji";
+};
+export declare const Unicode: {
+    toUppercase(ch: CodePoint): CodePoint;
+    toCodePoint(ch: Character): CodePoint;
+    toCharacter(ch: CodePoint): UnicodeCharacter;
+    isCharacter(ch: Character | ListOfCharacter): ch is Character;
+    toCodeUnit(ch: Character): [CodeUnit, CodeUnit?];
+    iterateByCodePoint(x: string): UnicodeCharacter[];
+    characterMatchPropertyValue(ch: Character | ListOfCharacter, property: Table69_NonbinaryUnicodePropertiesCanonicalized, value: string | undefined, rer: RegExpRecord | undefined): boolean;
+    getStringPropertySet(property: keyof typeof Table71_BinaryPropertyOfStrings): readonly ListOfCharacter[];
+    /** https://www.unicode.org/reports/tr44/#Simple_Case_Folding */
+    SimpleOrCommonCaseFoldingMapping(ch: Character): Character | undefined;
+    iterateCharacterByCodePoint(string: Character | ListOfCharacter): IterableIterator<Character>;
+};
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type BMPCharacter = string & {
+    description: 'A code unit';
+    length: 1;
+};
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type UnicodeCharacter = string & {
+    description: 'A code point';
+    length: 1 | 2;
+};
+/** https://tc39.es/ecma262/#sec-pattern-semantics */
+export type Character = BMPCharacter | UnicodeCharacter;
+export type ListOfCharacter = string & {
+    __brand__: 'ListOfCharacter';
+};
+/** https://developer.mozilla.org/en-US/docs/Glossary/Code_point */
+export type CodePoint = number & {
+    __brand__: 'CodePoint';
+};
+/** https://developer.mozilla.org/en-US/docs/Glossary/Code_unit */
+export type CodeUnit = number & {
+    __brand__: 'CodeUnit';
+};
+//# sourceMappingURL=Unicode.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Unicode.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/Unicode.mts"],"names":[],"mappings":"AAIA,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,OAAO,CAAC;AAEhE,eAAO,MAAM,kBAAkB,GAAI,IAAI,MAAM,YAAiC,CAAC;AAC/E,eAAO,MAAM,mBAAmB,GAAI,IAAI,MAAM,YAAiC,CAAC;AAChF,kEAAkE;AAClE,eAAO,MAAM,kCAAkC;;;;;;;CAOrC,CAAC;AAEX,MAAM,MAAM,+CAA+C,GAAG,OAAO,kCAAkC,CAAC,MAAM,OAAO,kCAAkC,CAAC,CAAC;AAEzJ,+DAA+D;AAC/D,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmGlC,CAAC;AAGX,0EAA0E;AAC1E,eAAO,MAAM,+BAA+B;;;;;;;;CAQlC,CAAC;AAKX,eAAO,MAAM,OAAO;oBACF,SAAS,GAAG,SAAS;oBAGrB,SAAS,GAAG,SAAS;oBAGrB,SAAS,GAAG,gBAAgB;oBAG5B,SAAS,GAAG,eAAe,GAAG,EAAE,IAAI,SAAS;mBAG9C,SAAS,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;0BAK1B,MAAM,GAAG,gBAAgB,EAAE;oCAGjB,SAAS,GAAG,eAAe,YAAY,+CAA+C,SAAS,MAAM,GAAG,SAAS,OAAO,YAAY,GAAG,SAAS;mCAoDjJ,MAAM,OAAO,+BAA+B;IAK3E,gEAAgE;yCAO3B,SAAS,GAAG,SAAS,GAAG,SAAS;wCASlC,SAAS,GAAG,eAAe,GACzB,gBAAgB,CAAC,SAAS,CAAC;CAElE,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC;AAC9E,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG;IAAE,WAAW,EAAE,cAAc,CAAC;IAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAA;CAAE,CAAC;AACvF,qDAAqD;AACrD,MAAM,MAAM,SAAS,GAAG,YAAY,GAAG,gBAAgB,CAAC;AAExD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG;IAAE,SAAS,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAExE,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG;IAAE,SAAS,EAAE,WAAW,CAAA;CAAE,CAAC;AAE5D,kEAAkE;AAClE,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG;IAAE,SAAS,EAAE,UAAU,CAAA;CAAE,CAAC"}

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

@@ -0,0 +1,4 @@
+import { type ValueEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function Evaluate_UpdateExpression({ LeftHandSideExpression, operator, UnaryExpression }: ParseNode.UpdateExpression): ValueEvaluator;
+//# sourceMappingURL=UpdateExpression.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"UpdateExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/UpdateExpression.mts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAYjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAQzD,wBAAiB,yBAAyB,CAAC,EAAE,sBAAsB,EAAE,QAAQ,EAAE,eAAe,EAAE,EAAE,SAAS,CAAC,gBAAgB,GAAG,cAAc,CAyG5I"}

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

@@ -0,0 +1,7 @@
+import { type PlainEvaluator } from '../evaluator.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+export declare function Evaluate_VariableDeclarationList(VariableDeclarationList: ParseNode.VariableDeclarationList): Generator<import("../evaluator.mts").EvaluatorYieldType, import("../completion.mts").PlainCompletion<void>, import("../evaluator.mts").EvaluatorNextType>;
+/** https://tc39.es/ecma262/#sec-variable-statement-runtime-semantics-evaluation */
+export declare function Evaluate_VariableStatement({ VariableDeclarationList }: ParseNode.VariableStatement): PlainEvaluator;
+//# sourceMappingURL=VariableStatement.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VariableStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/VariableStatement.mts"],"names":[],"mappings":"AAQA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AA0CzD,mFAAmF;AAKnF,wBAAiB,gCAAgC,CAAC,uBAAuB,EAAE,SAAS,CAAC,uBAAuB,6JAO3G;AAED,mFAAmF;AAEnF,wBAAiB,0BAA0B,CAAC,EAAE,uBAAuB,EAAE,EAAE,SAAS,CAAC,iBAAiB,GAAG,cAAc,CAIpH"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"WithStatement.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/WithStatement.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAUrC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,+EAA+E;AAE/E,wBAAiB,sBAAsB,CAAC,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,SAAS,CAAC,aAAa;;;;;;;;;;;mQAiBzF"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"YieldExpression.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/YieldExpression.mts"],"names":[],"mappings":"AAyBA,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACjE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,+FAA+F;AAK/F,wBAAiB,wBAAwB,CAAC,EAAE,OAAO,EAAE,oBAAoB,EAAE,EAAE,SAAS,CAAC,eAAe,GAAG,cAAc,CA4ItH"}

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

@@ -0,0 +1,109 @@
+export * from './IdentifierReference.mts';
+export * from './This.mts';
+export * from './Literal.mts';
+export * from './ClassExpression.mts';
+export * from './ClassDefinitionEvaluation.mts';
+export * from './DefineMethod.mts';
+export * from './PropertyName.mts';
+export * from './AdditiveExpression.mts';
+export * from './AssignmentExpression.mts';
+export * from './BitwiseOperators.mts';
+export * from './CoalesceExpression.mts';
+export * from './EmptyStatement.mts';
+export * from './ExponentiationExpression.mts';
+export * from './IfStatement.mts';
+export * from './ImportCall.mts';
+export * from './MultiplicativeExpression.mts';
+export * from './ThrowStatement.mts';
+export * from './UpdateExpression.mts';
+export * from './GlobalDeclarationInstantiation.mts';
+export * from './InstantiateFunctionObject.mts';
+export * from './Script.mts';
+export * from './ScriptBody.mts';
+export * from './StatementList.mts';
+export * from './ExpressionStatement.mts';
+export * from './VariableStatement.mts';
+export * from './FunctionDeclaration.mts';
+export * from './CallExpression.mts';
+export * from './EvaluateCall.mts';
+export * from './ArgumentListEvaluation.mts';
+export * from './EvaluateBody.mts';
+export * from './FunctionDeclarationInstantiation.mts';
+export * from './FunctionStatementList.mts';
+export * from './IteratorBindingInitialization.mts';
+export * from './ReturnStatement.mts';
+export * from './ParenthesizedExpression.mts';
+export * from './MemberExpression.mts';
+export * from './EvaluatePropertyAccess.mts';
+export * from './LexicalDeclaration.mts';
+export * from './ObjectLiteral.mts';
+export * from './PropertyDefinitionEvaluation.mts';
+export * from './FunctionExpression.mts';
+export * from './NamedEvaluation.mts';
+export * from './TryStatement.mts';
+export * from './Block.mts';
+export * from './ArrayLiteral.mts';
+export * from './UnaryExpression.mts';
+export * from './EqualityExpression.mts';
+export * from './LogicalANDExpression.mts';
+export * from './LogicalORExpression.mts';
+export * from './NewExpression.mts';
+export * from './ShiftExpression.mts';
+export * from './SuperCall.mts';
+export * from './SuperProperty.mts';
+export * from './BindingInitialization.mts';
+export * from './AsyncFunctionExpression.mts';
+export * from './RelationalExpression.mts';
+export * from './BreakableStatement.mts';
+export * from './LabelledEvaluation.mts';
+export * from './TemplateLiteral.mts';
+export * from './SwitchStatement.mts';
+export * from './CreateDynamicFunction.mts';
+export * from './GeneratorExpression.mts';
+export * from './ArrowFunction.mts';
+export * from './AsyncArrowFunction.mts';
+export * from './BreakStatement.mts';
+export * from './AsyncGeneratorExpression.mts';
+export * from './HoistableDeclaration.mts';
+export * from './CommaOperator.mts';
+export * from './YieldExpression.mts';
+export * from './StringIndexOf.mts';
+export * from './NumberToBigInt.mts';
+export * from './ConditionalExpression.mts';
+export * from './RegularExpressionLiteral.mts';
+export * from './RegExp.mts';
+export * from './StringPad.mts';
+export * from './TrimString.mts';
+export * from './NewTarget.mts';
+export * from './AwaitExpression.mts';
+export * from './ClassDeclaration.mts';
+export * from './WithStatement.mts';
+export * from './Module.mts';
+export * from './ModuleBody.mts';
+export * from './ImportDeclaration.mts';
+export * from './ExportDeclaration.mts';
+export * from './OptionalExpression.mts';
+export * from './TaggedTemplateExpression.mts';
+export * from './GetSubstitution.mts';
+export * from './ContinueStatement.mts';
+export * from './LabelledStatement.mts';
+export * from './MV.mts';
+export * from './ApplyStringOrNumericBinaryOperator.mts';
+export * from './EvaluateStringOrNumericBinaryExpression.mts';
+export * from './ImportMeta.mts';
+export * from './DebuggerStatement.mts';
+export * from './PropertyBindingInitialization.mts';
+export * from './KeyedBindingInitialization.mts';
+export * from './DestructuringAssignmentEvaluation.mts';
+export * from './RestBindingInitialization.mts';
+export * from './Unicode.mts';
+export * from './MethodDefinitionEvaluation.mts';
+export * from './ClassFieldDefinitionEvaluation.mts';
+export * from './InstantiateOrdinaryFunctionExpression.mts';
+export * from './InstantiateGeneratorFunctionExpression.mts';
+export * from './InstantiateArrowFunctionExpression.mts';
+export * from './InstantiateAsyncArrowFunctionExpression.mts';
+export * from './InstantiateAsyncFunctionExpression.mts';
+export * from './InstantiateAsyncGeneratorFunctionExpression.mts';
+export * from './ClassStaticBlockDefinitionEvaluation.mts';
+//# sourceMappingURL=all.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"all.d.mts","sourceRoot":"","sources":["../../src/runtime-semantics/all.mts"],"names":[],"mappings":"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"}

package/declaration/static-semantics/BodyText.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-static-semantics-bodytext */
+export declare function BodyText(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral): string;
+//# sourceMappingURL=BodyText.d.mts.map

package/declaration/static-semantics/BodyText.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BodyText.d.mts","sourceRoot":"","sources":["../../src/static-semantics/BodyText.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,6DAA6D;AAE7D,wBAAgB,QAAQ,CAAC,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,UAEpF"}

package/declaration/static-semantics/BoundNames.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { JSStringValue } from '../value.mts';
+export declare function BoundNames(node: ParseNode | readonly ParseNode[]): JSStringValue[];
+//# sourceMappingURL=BoundNames.d.mts.map

package/declaration/static-semantics/BoundNames.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BoundNames.d.mts","sourceRoot":"","sources":["../../src/static-semantics/BoundNames.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAS,MAAM,cAAc,CAAC;AAGpD,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE,GAAG,aAAa,EAAE,CA+FlF"}

package/declaration/static-semantics/CharacterValue.d.mts

@@ -0,0 +1,6 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type CodePoint } from '#self';
+export type CharacterValueAcceptNode = ParseNode.RegExp.CharacterEscape | ParseNode.RegExp.RegExpUnicodeEscapeSequence | ParseNode.RegExp.ClassAtom | ParseNode.RegExp.ClassEscape | ParseNode.RegExp.ClassSetCharacter;
+/** https://tc39.es/ecma262/#sec-patterns-static-semantics-character-value */
+export declare function CharacterValue(node: CharacterValueAcceptNode): CodePoint;
+//# sourceMappingURL=CharacterValue.d.mts.map

package/declaration/static-semantics/CharacterValue.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CharacterValue.d.mts","sourceRoot":"","sources":["../../src/static-semantics/CharacterValue.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,OAAO,EAAW,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEhD,MAAM,MAAM,wBAAwB,GAChC,SAAS,CAAC,MAAM,CAAC,eAAe,GAChC,SAAS,CAAC,MAAM,CAAC,2BAA2B,GAC5C,SAAS,CAAC,MAAM,CAAC,SAAS,GAC1B,SAAS,CAAC,MAAM,CAAC,WAAW,GAC5B,SAAS,CAAC,MAAM,CAAC,iBAAiB,CAAC;AAEvC,6EAA6E;AAC7E,wBAAgB,cAAc,CAAC,IAAI,EAAE,wBAAwB,GAAG,SAAS,CAkGxE"}

package/declaration/static-semantics/CodePointAt.d.mts

@@ -0,0 +1,8 @@
+import { type CodePoint } from '#self';
+/** https://tc39.es/ecma262/#sec-codepointat */
+export declare function CodePointAt(string: string, position: number): {
+    CodePoint: CodePoint;
+    CodeUnitCount: number;
+    IsUnpairedSurrogate: boolean;
+};
+//# sourceMappingURL=CodePointAt.d.mts.map

package/declaration/static-semantics/CodePointAt.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodePointAt.d.mts","sourceRoot":"","sources":["../../src/static-semantics/CodePointAt.mts"],"names":[],"mappings":"AAGA,OAAO,EAA2C,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAEhF,+CAA+C;AAC/C,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;eAarC,SAAS;;;EAiC/B"}

package/declaration/static-semantics/CodePointsToString.d.mts

@@ -0,0 +1,3 @@
+/** https://tc39.es/ecma262/#sec-codepointstostring */
+export declare function CodePointsToString(text: string): string;
+//# sourceMappingURL=CodePointsToString.d.mts.map

package/declaration/static-semantics/CodePointsToString.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CodePointsToString.d.mts","sourceRoot":"","sources":["../../src/static-semantics/CodePointsToString.mts"],"names":[],"mappings":"AAGA,sDAAsD;AACtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,UAU9C"}

package/declaration/static-semantics/ConstructorMethod.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-static-semantics-constructormethod */
+export declare function ConstructorMethod(ClassElementList: ParseNode.ClassElementList): ParseNode.MethodDefinition | undefined;
+//# sourceMappingURL=ConstructorMethod.d.mts.map

package/declaration/static-semantics/ConstructorMethod.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConstructorMethod.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ConstructorMethod.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,sEAAsE;AAItE,wBAAgB,iBAAiB,CAAC,gBAAgB,EAAE,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAEtH"}

package/declaration/static-semantics/ContainsArguments.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-static-semantics-containsarguments */
+export declare function ContainsArguments(node: ParseNode): ParseNode.IdentifierReference | null;
+//# sourceMappingURL=ContainsArguments.d.mts.map

package/declaration/static-semantics/ContainsArguments.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainsArguments.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ContainsArguments.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,sEAAsE;AACtE,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,CAAC,mBAAmB,GAAG,IAAI,CA6BvF"}

package/declaration/static-semantics/ContainsExpression.d.mts

@@ -0,0 +1,3 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function ContainsExpression(node: ParseNode | readonly ParseNode[]): boolean;
+//# sourceMappingURL=ContainsExpression.d.mts.map

package/declaration/static-semantics/ContainsExpression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ContainsExpression.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ContainsExpression.mts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE,GAAG,OAAO,CAuDlF"}

package/declaration/static-semantics/DeclarationPart.d.mts

@@ -0,0 +1,3 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function DeclarationPart<T extends ParseNode>(node: T): T;
+//# sourceMappingURL=DeclarationPart.d.mts.map

package/declaration/static-semantics/DeclarationPart.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeclarationPart.d.mts","sourceRoot":"","sources":["../../src/static-semantics/DeclarationPart.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,wBAAgB,eAAe,CAAC,CAAC,SAAS,SAAS,EAAE,IAAI,EAAE,CAAC,GAAG,CAAC,CAE/D"}

package/declaration/static-semantics/ExpectedArgumentCount.d.mts

@@ -0,0 +1,3 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function ExpectedArgumentCount(FormalParameterList: ParseNode.FormalParameters): number;
+//# sourceMappingURL=ExpectedArgumentCount.d.mts.map

package/declaration/static-semantics/ExpectedArgumentCount.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpectedArgumentCount.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ExpectedArgumentCount.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,wBAAgB,qBAAqB,CAAC,mBAAmB,EAAE,SAAS,CAAC,gBAAgB,UAsBpF"}

package/declaration/static-semantics/ExportEntries.d.mts

@@ -0,0 +1,11 @@
+import { JSStringValue, NullValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type ModuleRequestRecord } from './all.mts';
+export declare function ExportEntries(node: ParseNode | readonly ParseNode[]): ExportEntry[];
+export interface ExportEntry {
+    readonly ModuleRequest: ModuleRequestRecord | NullValue;
+    readonly ImportName: JSStringValue | NullValue | 'all' | 'all-but-default';
+    readonly LocalName: JSStringValue | NullValue;
+    readonly ExportName: JSStringValue | NullValue;
+}
+//# sourceMappingURL=ExportEntries.d.mts.map

package/declaration/static-semantics/ExportEntries.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportEntries.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ExportEntries.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAS,MAAM,cAAc,CAAC;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAC+C,KAAK,mBAAmB,EAC7E,MAAM,WAAW,CAAC;AAEnB,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE,GAAG,WAAW,EAAE,CAkHnF;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,aAAa,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACxD,QAAQ,CAAC,UAAU,EAAE,aAAa,GAAG,SAAS,GAAG,KAAK,GAAG,iBAAiB,CAAC;IAC3E,QAAQ,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,CAAC;IAC9C,QAAQ,CAAC,UAAU,EAAE,aAAa,GAAG,SAAS,CAAC;CAChD"}

package/declaration/static-semantics/ExportEntriesForModule.d.mts

@@ -0,0 +1,5 @@
+import { NullValue } from '../value.mts';
+import type { ParseNode } from '../parser/ParseNode.mts';
+import { type ExportEntry, type ModuleRequestRecord } from './all.mts';
+export declare function ExportEntriesForModule(node: ParseNode | readonly ParseNode[], module: ModuleRequestRecord | NullValue): ExportEntry[];
+//# sourceMappingURL=ExportEntriesForModule.d.mts.map

package/declaration/static-semantics/ExportEntriesForModule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExportEntriesForModule.d.mts","sourceRoot":"","sources":["../../src/static-semantics/ExportEntriesForModule.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAS,MAAM,cAAc,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAe,KAAK,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAEpF,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,SAAS,EAAE,EAAE,MAAM,EAAE,mBAAmB,GAAG,SAAS,GAAG,WAAW,EAAE,CAyDrI"}

package/declaration/static-semantics/FlagText.d.mts

@@ -0,0 +1,4 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+/** https://tc39.es/ecma262/#sec-static-semantics-flagtext */
+export declare function FlagText(RegularExpressionLiteral: ParseNode.RegularExpressionLiteral): string;
+//# sourceMappingURL=FlagText.d.mts.map

package/declaration/static-semantics/FlagText.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FlagText.d.mts","sourceRoot":"","sources":["../../src/static-semantics/FlagText.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,6DAA6D;AAE7D,wBAAgB,QAAQ,CAAC,wBAAwB,EAAE,SAAS,CAAC,wBAAwB,UAEpF"}

package/declaration/static-semantics/HasInitializer.d.mts

@@ -0,0 +1,5 @@
+import type { ParseNode } from '../parser/ParseNode.mts';
+export declare function HasInitializer(node: ParseNode): node is ParseNode & {
+    readonly Initializer: ParseNode.Initializer;
+};
+//# sourceMappingURL=HasInitializer.d.mts.map

package/declaration/static-semantics/HasInitializer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HasInitializer.d.mts","sourceRoot":"","sources":["../../src/static-semantics/HasInitializer.mts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,IAAI,SAAS,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,WAAW,CAAC;CAAE,CAEpH"}