@vscode/chat-lib 0.1.2-0 → 0.1.2

package/dist/src/_internal/extension/completions-core/vscode-node/lib/src/ghostText/statementTree.js

@@ -1,785 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatementTree = exports.StatementNode = void 0;
-const parse_1 = require("../../../prompt/src/parse");
-class StatementNode {
-    constructor(node) {
-        this.node = node;
-        this.children = [];
-        this.collapsed = false;
-    }
-    addChild(child) {
-        child.parent = this;
-        child.nextSibling = undefined;
-        if (this.children.length > 0) {
-            this.children[this.children.length - 1].nextSibling = child;
-        }
-        this.children.push(child);
-    }
-    /**
-     * Called after the last child is added to this node when the tree is being
-     * constructed. This is a callback derived classes can use to do any additional
-     * processing once this branch of the tree is complete. The default behavior
-     * is to do nothing.
-     */
-    childrenFinished() { }
-    containsStatement(stmt) {
-        return this.node.startIndex <= stmt.node.startIndex && this.node.endIndex >= stmt.node.endIndex;
-    }
-    statementAt(offset) {
-        if (this.node.startIndex > offset || this.node.endIndex < offset) {
-            return undefined;
-        }
-        let innerMatch = undefined;
-        this.children.find(stmt => {
-            innerMatch = stmt.statementAt(offset);
-            return innerMatch !== undefined;
-        });
-        return innerMatch ?? this;
-    }
-    /** Treat this node and its children as a single statement */
-    collapse() {
-        this.children.length = 0;
-        this.collapsed = true;
-    }
-    get description() {
-        return `${this.node.type} ([${this.node.startPosition.row},${this.node.startPosition.column}]..[${this.node.endPosition.row},${this.node.endPosition.column}]): ${JSON.stringify(this.node.text.length > 33 ? this.node.text.substring(0, 15) + '...' + this.node.text.slice(-15) : this.node.text)}`;
-    }
-    dump(prefix1 = '', prefix2 = '') {
-        const result = [`${prefix1}${this.description}`];
-        this.children.forEach(child => {
-            result.push(child.dump(`${prefix2}+- `, child.nextSibling === undefined ? `${prefix2}   ` : `${prefix2}|  `));
-        });
-        return result.join('\n');
-    }
-    dumpPath(prefix1 = '', prefix2 = '', forChild = false) {
-        if (this.parent) {
-            const path = this.parent.dumpPath(prefix1, prefix2, true);
-            const indentSize = path.length - path.lastIndexOf('\n') - 1 - prefix2.length;
-            const indent = ' '.repeat(indentSize);
-            const nextPrefix = forChild ? `\n${prefix2}${indent}+- ` : '';
-            return path + this.description + nextPrefix;
-        }
-        else {
-            const nextPrefix = forChild ? `\n${prefix2}+- ` : '';
-            return prefix1 + this.description + nextPrefix;
-        }
-    }
-}
-exports.StatementNode = StatementNode;
-/**
- * A simplified view of a syntax tree.
- *
- * It contains only nodes which represent complete statements. Because statements may
- * be compound, a single statement may contain other statements within it.
- *
- * "Statement" refers to a syntactic unit of the language. It represents the smallest
- * division of a code completion we would consider when truncating. It may be a simple
- * statement such as:
- *
- *   `x = 1;`
- *
- * or a compound statement such as:
- *
- *   `if (x > 0) { x = 2; }`
- *
- * where the entire string comprises the parent statement, and `x = 2;` is
- * a child statement of the parent. Note that `x > 0` is not a statement, but
- * an expression.
- *
- * The view is further constrained to a portion of the overall document (the start and
- * end offsets). This view contains all statements which intersect that region, so
- * containing statements are included in the view, even though they may extend
- * beyond the region.
- */
-class StatementTree {
-    static isSupported(languageId) {
-        return (JSStatementTree.languageIds.has(languageId) ||
-            TSStatementTree.languageIds.has(languageId) ||
-            PyStatementTree.languageIds.has(languageId) ||
-            GoStatementTree.languageIds.has(languageId) ||
-            PhpStatementTree.languageIds.has(languageId) ||
-            RubyStatementTree.languageIds.has(languageId) ||
-            JavaStatementTree.languageIds.has(languageId) ||
-            CSharpStatementTree.languageIds.has(languageId) ||
-            CStatementTree.languageIds.has(languageId));
-    }
-    static isTrimmedByDefault(languageId) {
-        return (JSStatementTree.languageIds.has(languageId) ||
-            TSStatementTree.languageIds.has(languageId) ||
-            GoStatementTree.languageIds.has(languageId));
-    }
-    static create(languageId, text, startOffset, endOffset) {
-        if (JSStatementTree.languageIds.has(languageId)) {
-            return new JSStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (TSStatementTree.languageIds.has(languageId)) {
-            return new TSStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (PyStatementTree.languageIds.has(languageId)) {
-            return new PyStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (GoStatementTree.languageIds.has(languageId)) {
-            return new GoStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (JavaStatementTree.languageIds.has(languageId)) {
-            return new JavaStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (PhpStatementTree.languageIds.has(languageId)) {
-            return new PhpStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (RubyStatementTree.languageIds.has(languageId)) {
-            return new RubyStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (CSharpStatementTree.languageIds.has(languageId)) {
-            return new CSharpStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else if (CStatementTree.languageIds.has(languageId)) {
-            return new CStatementTree(languageId, text, startOffset, endOffset);
-        }
-        else {
-            throw new Error(`Unsupported languageId: ${languageId}`);
-        }
-    }
-    constructor(languageId, text, startOffset, endOffset) {
-        this.languageId = languageId;
-        this.text = text;
-        this.startOffset = startOffset;
-        this.endOffset = endOffset;
-        this.statements = [];
-    }
-    [Symbol.dispose]() {
-        if (this.tree) {
-            this.tree.delete();
-            this.tree = undefined;
-        }
-    }
-    clear() {
-        this.statements.length = 0;
-    }
-    statementAt(offset) {
-        let match = undefined;
-        this.statements.find(stmt => {
-            match = stmt.statementAt(offset);
-            return match !== undefined;
-        });
-        return match;
-    }
-    async build() {
-        const parents = [];
-        this.clear();
-        const tree = await this.parse();
-        const query = this.getStatementQuery(tree);
-        query
-            .captures(tree.rootNode, {
-            startPosition: this.offsetToPosition(this.startOffset),
-            endPosition: this.offsetToPosition(this.endOffset),
-        })
-            .forEach(capture => {
-            const stmt = this.createNode(capture.node);
-            while (parents.length > 0 && !parents[0].containsStatement(stmt)) {
-                const completed = parents.shift(); // not a parent
-                completed?.childrenFinished();
-            }
-            if (parents.length > 0) {
-                parents[0].addChild(stmt); // this is our parent
-            }
-            else {
-                this.addStatement(stmt); // top-level statement
-            }
-            parents.unshift(stmt); // add to the stack
-        });
-        // finish up
-        parents.forEach(stmt => stmt.childrenFinished());
-    }
-    addStatement(stmt) {
-        stmt.parent = undefined;
-        stmt.nextSibling = undefined;
-        if (this.statements.length > 0) {
-            this.statements[this.statements.length - 1].nextSibling = stmt;
-        }
-        this.statements.push(stmt);
-    }
-    async parse() {
-        if (!this.tree) {
-            this.tree = await (0, parse_1.parseTreeSitter)(this.languageId, this.text);
-        }
-        return this.tree;
-    }
-    getStatementQuery(tree) {
-        return this.getQuery(tree.getLanguage(), this.getStatementQueryText());
-    }
-    getQuery(language, queryText) {
-        // TODO: query objects can be cached and reused
-        return language.query(queryText);
-    }
-    offsetToPosition(offset) {
-        const lines = this.text.slice(0, offset).split('\n');
-        const row = lines.length - 1;
-        const column = lines[lines.length - 1].length;
-        return { row, column };
-    }
-    dump(prefix = '') {
-        const result = [];
-        this.statements.forEach((stmt, idx) => {
-            const idxStr = `[${idx}]`;
-            const idxSpaces = ' '.repeat(idxStr.length);
-            result.push(stmt.dump(`${prefix} ${idxStr} `, `${prefix} ${idxSpaces} `));
-        });
-        return result.join('\n');
-    }
-}
-exports.StatementTree = StatementTree;
-/*
- * Javascript and Typescript implementation
- */
-class JSStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'function_declaration',
-        'generator_function_declaration',
-        'class_declaration',
-        'statement_block',
-        'if_statement',
-        'switch_statement',
-        'for_statement',
-        'for_in_statement',
-        'while_statement',
-        'do_statement',
-        'try_statement',
-        'with_statement',
-        'labeled_statement',
-        'method_definition',
-        'interface_declaration',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && JSStatementNode.compoundTypeNames.has(this.node.type);
-    }
-    childrenFinished() {
-        if (this.isSingleLineIfStatement()) {
-            this.collapse();
-        }
-    }
-    isSingleLineIfStatement() {
-        // must be an if statement
-        if (this.node.type !== 'if_statement') {
-            return false;
-        }
-        // must be a single line
-        if (this.node.startPosition.row !== this.node.endPosition.row) {
-            return false;
-        }
-        // Exclude if statements with braces so that block position is correct:
-        // can have a single statement without braces
-        if (this.children.length === 1 && this.children[0].node.type !== 'statement_block') {
-            return true;
-        }
-        // or two statements without braces if an else is present
-        if (this.children.length === 2 &&
-            this.node.childForFieldName('alternative') !== null &&
-            this.children[0].node.type !== 'statement_block' &&
-            this.children[1].node.type !== 'statement_block') {
-            return true;
-        }
-        return false;
-    }
-}
-class JSStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['javascript', 'javascriptreact', 'jsx']); }
-    createNode(node) {
-        return new JSStatementNode(node);
-    }
-    getStatementQueryText() {
-        // From https://github.com/tree-sitter/tree-sitter-javascript/blob/fdeb68ac8d2bd5a78b943528bb68ceda3aade2eb/grammar.js#L199-L226
-        // Because `statement` is declared `inline` in this version of the
-        // grammar, we search for each choice from its definition plus two
-        // class constructs we want to consider for trimming.
-        return `[
-			(export_statement)
-			(import_statement)
-			(debugger_statement)
-			(expression_statement)
-			(declaration)
-			(statement_block)
-			(if_statement)
-			(switch_statement)
-			(for_statement)
-			(for_in_statement)
-			(while_statement)
-			(do_statement)
-			(try_statement)
-			(with_statement)
-			(break_statement)
-			(continue_statement)
-			(return_statement)
-			(throw_statement)
-			(empty_statement)
-			(labeled_statement)
-			(method_definition)
-			(field_definition)
-		] @statement`;
-    }
-}
-class TSStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['typescript', 'typescriptreact']); }
-    createNode(node) {
-        return new JSStatementNode(node);
-    }
-    getStatementQueryText() {
-        // From https://github.com/tree-sitter/tree-sitter-javascript/blob/fdeb68ac8d2bd5a78b943528bb68ceda3aade2eb/grammar.js#L199-L226
-        // Because `statement` is declared `inline` in this version of the
-        // grammar, we search for each choice from its definition plus two
-        // class constructs we want to consider for trimming.
-        return `[
-			(export_statement)
-			(import_statement)
-			(debugger_statement)
-			(expression_statement)
-			(declaration)
-			(statement_block)
-			(if_statement)
-			(switch_statement)
-			(for_statement)
-			(for_in_statement)
-			(while_statement)
-			(do_statement)
-			(try_statement)
-			(with_statement)
-			(break_statement)
-			(continue_statement)
-			(return_statement)
-			(throw_statement)
-			(empty_statement)
-			(labeled_statement)
-			(method_definition)
-			(public_field_definition)
-		] @statement`;
-    }
-}
-/*
- * Python implementation
- */
-class PyStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'if_statement',
-        'for_statement',
-        'while_statement',
-        'try_statement',
-        'with_statement',
-        'function_definition',
-        'class_definition',
-        'decorated_definition',
-        'match_statement',
-        'block',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && PyStatementNode.compoundTypeNames.has(this.node.type);
-    }
-    childrenFinished() {
-        if (this.isSingleLineIfStatement()) {
-            this.collapse();
-        }
-    }
-    isSingleLineIfStatement() {
-        // must be an if statement
-        if (this.node.type !== 'if_statement') {
-            return false;
-        }
-        // must be a single line
-        return this.node.startPosition.row === this.node.endPosition.row;
-    }
-}
-class PyStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['python']); }
-    createNode(node) {
-        return new PyStatementNode(node);
-    }
-    getStatementQueryText() {
-        // Search for nodes of type `_simple_statement` and `_compound_statement`.
-        // Because these are both inlined, we search for each choice in the two
-        // definitions. It also adds `block` to more closely match the tree
-        // shape of JS/TS.
-        //
-        // For the _simple_statement definition see: https://github.com/tree-sitter/tree-sitter-python/blob/7473026494597de8bc403735b1bfec7ca846c0d6/grammar.js#L90-L106
-        // For the _compound_statement definition see: https://github.com/tree-sitter/tree-sitter-python/blob/7473026494597de8bc403735b1bfec7ca846c0d6/grammar.js#L230-L240
-        return `[
-			(future_import_statement)
-			(import_statement)
-			(import_from_statement)
-			(print_statement)
-			(assert_statement)
-			(expression_statement)
-			(return_statement)
-			(delete_statement)
-			(raise_statement)
-			(pass_statement)
-			(break_statement)
-			(continue_statement)
-			(global_statement)
-			(nonlocal_statement)
-			(exec_statement)
-			(if_statement)
-			(for_statement)
-			(while_statement)
-			(try_statement)
-			(with_statement)
-			(function_definition)
-			(class_definition)
-			(decorated_definition)
-			(match_statement)
-			(block)
-		] @statement`;
-    }
-}
-/*
- * Go implementation
- */
-class GoStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'function_declaration',
-        'method_declaration',
-        'if_statement',
-        'for_statement',
-        'expression_switch_statement',
-        'type_switch_statement',
-        'select_statement',
-        'block',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && GoStatementNode.compoundTypeNames.has(this.node.type);
-    }
-}
-class GoStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['go']); }
-    createNode(node) {
-        return new GoStatementNode(node);
-    }
-    getStatementQueryText() {
-        // Search for nodes of type `_top_level_declaration` and `_statement`.
-        // Because `_top_level_declaration` is inlined, we search for each
-        // choice in its definition. It also adds `block` to match the tree
-        // shape of JS/TS.
-        //
-        // For the _top_level_declaration definition see: https://github.com/tree-sitter/tree-sitter-go/blob/3c3775faa968158a8b4ac190a7fda867fd5fb748/grammar.js#L117-L122
-        return `[
-			(package_clause)
-			(function_declaration)
-			(method_declaration)
-			(import_declaration)
-			(_statement)
-			(block)
-		] @statement`;
-    }
-}
-/**
- * Php implementation
- */
-class PhpStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'if_statement',
-        'else_clause',
-        'else_if_clause',
-        'for_statement',
-        'foreach_statement',
-        'while_statement',
-        'do_statement',
-        'switch_statement',
-        'try_statement',
-        'catch_clause',
-        'finally_clause',
-        'anonymous_function',
-        'compound_statement',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && PhpStatementNode.compoundTypeNames.has(this.node.type);
-    }
-}
-class PhpStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['php']); }
-    createNode(node) {
-        return new PhpStatementNode(node);
-    }
-    getStatementQueryText() {
-        // Search for nodes of type `_statement` and a few other picked types.
-        // `compound_statement`, `method_declaration`, `property_declaration`, `const_declaration`, and `use_declaration` are
-        // not encompassed by `_statement` so we add them to the query to make multi-line reveal more useful.
-        // For the _statement definition see: https://github.com/tree-sitter/tree-sitter-php/blob/eb289f127fc341ae7129902a2dd1c6c197a4c1e7/common/define-grammar.js#L141
-        return `[
-			(statement)
-			(compound_statement)
-			(method_declaration)
-			(property_declaration)
-			(const_declaration)
-			(use_declaration)
-		] @statement`;
-    }
-}
-/**
- * Ruby implementation
- */
-class RubyStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set(['if', 'case', 'while', 'until', 'for', 'begin', 'module', 'class', 'method']); }
-    get isCompoundStatementType() {
-        return !this.collapsed && RubyStatementNode.compoundTypeNames.has(this.node.type);
-    }
-}
-class RubyStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['ruby']); }
-    createNode(node) {
-        return new RubyStatementNode(node);
-    }
-    //(if_modifier)
-    getStatementQueryText() {
-        return `[
-			(_statement)
-			(when)
-		] @statement`;
-    }
-}
-/*
- * Java implementation
- */
-class JavaStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'block',
-        'do_statement',
-        'enhanced_for_statement',
-        'for_statement',
-        'if_statement',
-        'labeled_statement',
-        'switch_expression',
-        'synchronized_statement',
-        'try_statement',
-        'try_with_resources_statement',
-        'while_statement',
-        'interface_declaration',
-        'method_declaration',
-        'constructor_declaration',
-        'compact_constructor_declaration',
-        'class_declaration',
-        'annotation_type_declaration',
-        'static_initializer',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && JavaStatementNode.compoundTypeNames.has(this.node.type);
-    }
-    childrenFinished() {
-        // Collapse if_statements on a single line
-        if (this.isSingleLineIfStatement()) {
-            this.collapse();
-        }
-    }
-    isSingleLineIfStatement() {
-        // must be an if statement
-        if (this.node.type !== 'if_statement') {
-            return false;
-        }
-        // must be a single line
-        if (this.node.startPosition.row !== this.node.endPosition.row) {
-            return false;
-        }
-        // Exclude if statements with braces so that block position is correct:
-        // can have a single statement without braces
-        if (this.children.length === 1 && this.children[0].node.type !== 'block') {
-            return true;
-        }
-        return false;
-    }
-}
-class JavaStatementTree extends StatementTree {
-    // Grammar via: https://github.com/tree-sitter/tree-sitter-java/blob/master/src/grammar.json
-    // Node types via: https://github.com/tree-sitter/tree-sitter-java/blob/master/src/node-types.json
-    static { this.languageIds = new Set(['java']); }
-    createNode(node) {
-        return new JavaStatementNode(node);
-    }
-    // _class_body_declaration is inlined, so add those subtypes to the query
-    getStatementQueryText() {
-        return `[
-			(statement)
-			(field_declaration)
-			(record_declaration)
-			(method_declaration)
-			(compact_constructor_declaration)
-			(class_declaration)
-			(interface_declaration)
-			(annotation_type_declaration)
-			(enum_declaration)
-			(block)
-			(static_initializer)
-			(constructor_declaration)
-			] @statement`;
-    }
-}
-/*
- * C# implementation
- */
-class CSharpStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'block',
-        'checked_statement',
-        'class_declaration',
-        'constructor_declaration',
-        'destructor_declaration',
-        'do_statement',
-        'fixed_statement',
-        'for_statement',
-        'foreach_statement',
-        'if_statement',
-        'interface_declaration',
-        'lock_statement',
-        'method_declaration',
-        'struct_declaration',
-        'switch_statement',
-        'try_statement',
-        'unsafe_statement',
-        'while_statement',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && CSharpStatementNode.compoundTypeNames.has(this.node.type);
-    }
-    childrenFinished() {
-        if (this.isSingleLineIfStatement()) {
-            this.collapse();
-        }
-    }
-    isSingleLineIfStatement() {
-        // must be an if statement
-        if (this.node.type !== 'if_statement') {
-            return false;
-        }
-        // must be a single line
-        if (this.node.startPosition.row !== this.node.endPosition.row) {
-            return false;
-        }
-        // Exclude if statements with braces so that block position is correct:
-        // can have a single statement without braces
-        if (this.children.length === 1 && this.children[0].node.type !== 'block') {
-            return true;
-        }
-        return false;
-    }
-}
-class CSharpStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['csharp']); }
-    createNode(node) {
-        return new CSharpStatementNode(node);
-    }
-    getStatementQueryText() {
-        return `[
-			(extern_alias_directive)
-			(using_directive)
-			(global_attribute)
-			(preproc_if)
-			(namespace_declaration)
-			(file_scoped_namespace_declaration)
-			(statement)
-			(type_declaration)
-			(declaration)
-			(accessor_declaration)
-			(block)
-		] @statement`;
-    }
-}
-/*
- * C, C++ implementation
- */
-class CStatementNode extends StatementNode {
-    static { this.compoundTypeNames = new Set([
-        'declaration',
-        'function_definition',
-        'enum_specifier',
-        'field_declaration_list',
-        'type_definition',
-        'compound_statement',
-        'if_statement',
-        'switch_statement',
-        'while_statement',
-        'for_statement',
-        'do_statement',
-        'preproc_if',
-        'preproc_ifdef',
-        // C++ specific:
-        'namespace_definition',
-        'class_specifier',
-        'field_declaration_list',
-        'concept_definition',
-        'template_declaration',
-    ]); }
-    get isCompoundStatementType() {
-        return !this.collapsed && CStatementNode.compoundTypeNames.has(this.node.type);
-    }
-    childrenFinished() {
-        if (this.isSingleLineDeclarationStatement() || this.isSingleLineConceptDefinition()) {
-            this.collapse();
-        }
-    }
-    isSingleLineDeclarationStatement() {
-        // must be an declaration statement
-        if (this.node.type !== 'declaration') {
-            return false;
-        }
-        // must be a single line
-        if (this.node.startPosition.row !== this.node.endPosition.row) {
-            return false;
-        }
-        return true;
-    }
-    isSingleLineConceptDefinition() {
-        // must be a concept definition
-        if (this.node.type !== 'concept_definition') {
-            return false;
-        }
-        // must be a single line
-        if (this.node.startPosition.row !== this.node.endPosition.row) {
-            return false;
-        }
-        return true;
-    }
-}
-class CStatementTree extends StatementTree {
-    static { this.languageIds = new Set(['c', 'cpp']); }
-    createNode(node) {
-        return new CStatementNode(node);
-    }
-    getStatementQueryText() {
-        return `[
-			(declaration)
-			(function_definition)
-			(type_definition)
-			(field_declaration)
-			(enum_specifier)
-			(return_statement)
-			(compound_statement)
-			(if_statement)
-			(expression_statement)
-			(switch_statement)
-			(break_statement)
-			(case_statement)
-			(while_statement)
-			(for_statement)
-			(do_statement)
-			(goto_statement)
-			(labeled_statement)
-			(preproc_if)
-			(preproc_def)
-			(preproc_ifdef)
-			(preproc_include)
-			(preproc_call)
-			(preproc_function_def)
-			(continue_statement)
-
-			;C++ specific:
-			(namespace_definition)
-			(class_specifier)
-			(field_declaration_list)
-			(field_declaration)
-			(concept_definition)
-			(compound_requirement)
-			(template_declaration)
-			(using_declaration)
-			(alias_declaration)
-			(static_assert_declaration)
-		] @statement`;
-    }
-}
-//# sourceMappingURL=statementTree.js.map