@tslite/parser 1.10.0 → 1.12.0

package/dist/visitor.d.ts

@@ -0,0 +1,15 @@
+import type { Node, NodeArray, Statement } from "./_namespaces/ts.js";
+/**
+ * Merges generated lexical declarations into a new statement list.
+ */
+export declare function mergeLexicalEnvironment(statements: NodeArray<Statement>, declarations: readonly Statement[] | undefined): NodeArray<Statement>;
+/**
+ * Appends generated lexical declarations to an array of statements.
+ */
+export declare function mergeLexicalEnvironment(statements: Statement[], declarations: readonly Statement[] | undefined): Statement[];
+/**
+ * Lifts a NodeArray containing only Statement nodes to a block.
+ *
+ * @param nodes The NodeArray.
+ */
+export declare function liftToBlock(nodes: readonly Node[]): Statement;

package/dist/visitor.js

@@ -0,0 +1,64 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/visitor.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, createBlock, createMap, createNodeArray, every, isCustomPrologue, isHoistedVariableStatement, isNodeArray, isPrologueDirective, isStatement, setTextRange, singleOrUndefined, some, } from "./_namespaces/ts.js";
+function findSpanEnd(array, test, start) {
+    let i = start;
+    while (i < array.length && test(array[i])) {
+        i++;
+    }
+    return i;
+}
+export function mergeLexicalEnvironment(statements, declarations) {
+    if (!some(declarations)) {
+        return statements;
+    }
+    // As declarações novas entram na lista em faixas, na ordem: os prólogos padrão (os da direita antes dos da
+    // esquerda), as variáveis içadas, os statements de inicialização (os novos antes dos que já estavam) e o resto da
+    // lista. A declaração de função içada, que tinha a faixa dela entre os prólogos e as variáveis, não existe na
+    // Linguagem.
+    const leftStandardPrologueEnd = findSpanEnd(statements, isPrologueDirective, 0);
+    const leftHoistedVariablesEnd = findSpanEnd(statements, isHoistedVariableStatement, leftStandardPrologueEnd);
+    const rightStandardPrologueEnd = findSpanEnd(declarations, isPrologueDirective, 0);
+    const rightHoistedVariablesEnd = findSpanEnd(declarations, isHoistedVariableStatement, rightStandardPrologueEnd);
+    const rightCustomPrologueEnd = findSpanEnd(declarations, isCustomPrologue, rightHoistedVariablesEnd);
+    Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues");
+    // As faixas da direita entram na esquerda de trás para a frente, para não recalcular o índice da esquerda.
+    const left = isNodeArray(statements) ? statements.slice() : statements;
+    if (rightCustomPrologueEnd > rightHoistedVariablesEnd) {
+        left.splice(leftHoistedVariablesEnd, 0, ...declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd));
+    }
+    if (rightHoistedVariablesEnd > rightStandardPrologueEnd) {
+        left.splice(leftStandardPrologueEnd, 0, ...declarations.slice(rightStandardPrologueEnd, rightHoistedVariablesEnd));
+    }
+    // splice standard prologues from right into left (that are not already in left)
+    if (rightStandardPrologueEnd > 0) {
+        if (leftStandardPrologueEnd === 0) {
+            left.splice(0, 0, ...declarations.slice(0, rightStandardPrologueEnd));
+        }
+        else {
+            const leftPrologues = createMap();
+            for (let i = 0; i < leftStandardPrologueEnd; i++) {
+                const leftPrologue = statements[i];
+                leftPrologues.set(leftPrologue.expression.text, true);
+            }
+            for (let i = rightStandardPrologueEnd - 1; i >= 0; i--) {
+                const rightPrologue = declarations[i];
+                if (!leftPrologues.has(rightPrologue.expression.text)) {
+                    left.unshift(rightPrologue);
+                }
+            }
+        }
+    }
+    if (isNodeArray(statements)) {
+        return setTextRange(createNodeArray(left, statements.hasTrailingComma), statements);
+    }
+    return statements;
+}
+/**
+ * Lifts a NodeArray containing only Statement nodes to a block.
+ *
+ * @param nodes The NodeArray.
+ */
+export function liftToBlock(nodes) {
+    Debug.assert(every(nodes, isStatement), "Cannot lift nodes to a Block.");
+    return singleOrUndefined(nodes) || createBlock(nodes);
+}

package/dist/visitorPublic.d.ts

@@ -0,0 +1,82 @@
+import * as ts from "./_namespaces/ts.js";
+import type { ConciseBody, FunctionBody, Node, NodeArray, ParameterDeclaration, Statement, TransformationContext, Visitor } from "./_namespaces/ts.js";
+/**
+ * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
+ *
+ * @param node The Node to visit.
+ * @param visitor The callback used to visit the Node.
+ * @param test A callback to execute to verify the Node is valid.
+ * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
+ */
+export declare function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T;
+/**
+ * Visits a Node using the supplied visitor, possibly returning a new Node in its place.
+ *
+ * @param node The Node to visit.
+ * @param visitor The callback used to visit the Node.
+ * @param test A callback to execute to verify the Node is valid.
+ * @param lift An optional callback to execute to lift a NodeArray into a valid Node.
+ */
+export declare function visitNode<T extends Node>(node: T | undefined, visitor: Visitor | undefined, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => T): T | undefined;
+/**
+ * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
+ *
+ * @param nodes The NodeArray to visit.
+ * @param visitor The callback used to visit a Node.
+ * @param test A node test to execute for each node.
+ * @param start An optional value indicating the starting offset at which to start visiting.
+ * @param count An optional value indicating the maximum number of nodes to visit.
+ */
+export declare function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T>;
+/**
+ * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
+ *
+ * @param nodes The NodeArray to visit.
+ * @param visitor The callback used to visit a Node.
+ * @param test A node test to execute for each node.
+ * @param start An optional value indicating the starting offset at which to start visiting.
+ * @param count An optional value indicating the maximum number of nodes to visit.
+ */
+export declare function visitNodes<T extends Node>(nodes: NodeArray<T> | undefined, visitor: Visitor, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<T> | undefined;
+/**
+ * Starts a new lexical environment and visits a statement list, ending the lexical environment
+ * and merging hoisted declarations upon completion.
+ */
+export declare function visitLexicalEnvironment(statements: NodeArray<Statement>, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean): ts.NodeArray<ts.Statement>;
+/**
+ * Starts a new lexical environment and visits a parameter list, suspending the lexical
+ * environment upon completion.
+ */
+export declare function visitParameterList(nodes: NodeArray<ParameterDeclaration>, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes): NodeArray<ParameterDeclaration>;
+export declare function visitParameterList(nodes: NodeArray<ParameterDeclaration> | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes): NodeArray<ParameterDeclaration> | undefined;
+/**
+ * Resumes a suspended lexical environment and visits a function body, ending the lexical
+ * environment and merging hoisted declarations upon completion.
+ */
+export declare function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody;
+/**
+ * Resumes a suspended lexical environment and visits a function body, ending the lexical
+ * environment and merging hoisted declarations upon completion.
+ */
+export declare function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined;
+/**
+ * Resumes a suspended lexical environment and visits a concise body, ending the lexical
+ * environment and merging hoisted declarations upon completion.
+ */
+export declare function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody;
+/**
+ * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
+ *
+ * @param node The Node whose children will be visited.
+ * @param visitor The callback used to visit each child.
+ * @param context A lexical environment context for the visitor.
+ */
+export declare function visitEachChild<T extends Node>(node: T, visitor: Visitor, context: TransformationContext): T;
+/**
+ * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place.
+ *
+ * @param node The Node whose children will be visited.
+ * @param visitor The callback used to visit each child.
+ * @param context A lexical environment context for the visitor.
+ */
+export declare function visitEachChild<T extends Node>(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined;

package/dist/visitorPublic.js

@@ -0,0 +1,352 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/visitorPublic.ts: o namespace virou módulo ES, com os imports explícitos.
+import * as ts from "./_namespaces/ts.js";
+import { Debug, convertToFunctionBody, createNodeArray, isArray, isArrayBindingElement, isBindingElement, isBindingName, isBlock, isCaseBlock, isCaseOrDefaultClause, isCatchClause, isConciseBody, isEntityName, isExportSpecifier, isExpression, isForInitializer, isIdentifier, isImportClause, isImportSpecifier, isJsxAttributeLike, isJsxAttributes, isJsxChild, isJsxClosingElement, isJsxClosingFragment, isJsxOpeningElement, isJsxOpeningFragment, isJsxTagNameExpression, isModifier, isModuleBody, isNamedExportBindings, isNamedImportBindings, isObjectLiteralElementLike, isParameterDeclaration, isPropertyName, isStatement, isStringLiteralOrJsxExpression, isTemplateHead, isTemplateMiddleOrTemplateTail, isTemplateSpan, isToken, isTypeElement, isTypeNode, isTypeParameterDeclaration, isVariableDeclaration, isVariableDeclarationList, liftToBlock, mergeLexicalEnvironment, or, setTextRange, singleOrUndefined, some, updateArrayBindingPattern, updateArrayLiteral, updateArrayTypeNode, updateArrowFunction, updateAsExpression, updateAwait, updateBinary, updateBindingElement, updateBlock, updateCall, updateCallChain, updateCallSignature, updateCaseBlock, updateCaseClause, updateCatchClause, updateCommaList, updateComputedPropertyName, updateConditional, updateConditionalTypeNode, updateDefaultClause, updateDelete, updateDo, updateElementAccess, updateElementAccessChain, updateExportAssignment, updateExportDeclaration, updateExportSpecifier, updateExpressionStatement, updateFor, updateForIn, updateForOf, updateFunctionTypeNode, updateIdentifier, updateIf, updateImportClause, updateImportDeclaration, updateImportSpecifier, updateImportTypeNode, updateIndexSignature, updateIndexedAccessTypeNode, updateInferTypeNode, updateIntersectionTypeNode, updateJsxAttribute, updateJsxAttributes, updateJsxClosingElement, updateJsxElement, updateJsxExpression, updateJsxFragment, updateJsxOpeningElement, updateJsxSelfClosingElement, updateJsxSpreadAttribute, updateLiteralTypeNode, updateMappedTypeNode, updateMetaProperty, updateMethodSignature, updateModuleBlock, updateModuleDeclaration, updateNamedExports, updateNamedImports, updateNamespaceExport, updateNamespaceImport, updateObjectBindingPattern, updateObjectLiteral, updateOptionalTypeNode, updateParameter, updateParen, updateParenthesizedType, updatePartiallyEmittedExpression, updatePostfix, updatePrefix, updatePropertyAccess, updatePropertyAccessChain, updatePropertyAssignment, updatePropertySignature, updateQualifiedName, updateRestTypeNode, updateReturn, updateShorthandPropertyAssignment, updateSourceFileNode, updateSpread, updateSpreadAssignment, updateSwitch, updateTemplateExpression, updateTemplateSpan, updateThrow, updateTry, updateTupleTypeNode, updateTypeAliasDeclaration, updateTypeLiteralNode, updateTypeOf, updateTypeOperatorNode, updateTypeParameterDeclaration, updateTypePredicateNodeWithModifier, updateTypeQueryNode, updateTypeReferenceNode, updateTypeScriptVariableDeclaration, updateUnionTypeNode, updateVariableDeclarationList, updateVariableStatement, updateWhile, } from "./_namespaces/ts.js";
+const isTypeNodeOrTypeParameterDeclaration = or(isTypeNode, isTypeParameterDeclaration);
+export function visitNode(node, visitor, test, lift) {
+    if (node === undefined || visitor === undefined) {
+        return node;
+    }
+    const visited = visitor(node);
+    if (visited === node) {
+        return node;
+    }
+    let visitedNode;
+    if (visited === undefined) {
+        return undefined;
+    }
+    else if (isArray(visited)) {
+        visitedNode = (lift || extractSingleNode)(visited);
+    }
+    else {
+        visitedNode = visited;
+    }
+    Debug.assertNode(visitedNode, test);
+    return visitedNode;
+}
+/**
+ * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place.
+ *
+ * @param nodes The NodeArray to visit.
+ * @param visitor The callback used to visit a Node.
+ * @param test A node test to execute for each node.
+ * @param start An optional value indicating the starting offset at which to start visiting.
+ * @param count An optional value indicating the maximum number of nodes to visit.
+ */
+export function visitNodes(nodes, visitor, test, start, count) {
+    if (nodes === undefined || visitor === undefined) {
+        return nodes;
+    }
+    let updated;
+    // Ensure start and count have valid values
+    const length = nodes.length;
+    if (start === undefined || start < 0) {
+        start = 0;
+    }
+    if (count === undefined || count > length - start) {
+        count = length - start;
+    }
+    if (start > 0 || count < length) {
+        // If we are not visiting all of the original nodes, we must always create a new array.
+        // Since this is a fragment of a node array, we do not copy over the previous location
+        // and will only copy over `hasTrailingComma` if we are including the last element.
+        updated = createNodeArray([], /*hasTrailingComma*/ nodes.hasTrailingComma && start + count === length);
+    }
+    // Visit each original node.
+    for (let i = 0; i < count; i++) {
+        const node = nodes[i + start];
+        const visited = node !== undefined ? visitor(node) : undefined;
+        if (updated !== undefined || visited === undefined || visited !== node) {
+            if (updated === undefined) {
+                // Ensure we have a copy of `nodes`, up to the current index.
+                updated = createNodeArray(nodes.slice(0, i), nodes.hasTrailingComma);
+                setTextRange(updated, nodes);
+            }
+            if (visited) {
+                if (isArray(visited)) {
+                    for (const visitedNode of visited) {
+                        Debug.assertNode(visitedNode, test);
+                        updated.push(visitedNode);
+                    }
+                }
+                else {
+                    Debug.assertNode(visited, test);
+                    updated.push(visited);
+                }
+            }
+        }
+    }
+    return updated || nodes;
+}
+/**
+ * Starts a new lexical environment and visits a statement list, ending the lexical environment
+ * and merging hoisted declarations upon completion.
+ */
+export function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict) {
+    context.startLexicalEnvironment();
+    statements = visitNodes(statements, visitor, isStatement, start);
+    if (ensureUseStrict)
+        statements = ts.ensureUseStrict(statements); // eslint-disable-line @typescript-eslint/no-unnecessary-qualifier
+    return mergeLexicalEnvironment(statements, context.endLexicalEnvironment());
+}
+export function visitParameterList(nodes, visitor, context, nodesVisitor = visitNodes) {
+    let updated;
+    context.startLexicalEnvironment();
+    if (nodes) {
+        context.setLexicalEnvironmentFlags(1 /* LexicalEnvironmentFlags.InParameters */, true);
+        updated = nodesVisitor(nodes, visitor, isParameterDeclaration);
+        context.setLexicalEnvironmentFlags(1 /* LexicalEnvironmentFlags.InParameters */, false);
+    }
+    context.suspendLexicalEnvironment();
+    return updated;
+}
+export function visitFunctionBody(node, visitor, context) {
+    context.resumeLexicalEnvironment();
+    const updated = visitNode(node, visitor, isConciseBody);
+    const declarations = context.endLexicalEnvironment();
+    if (some(declarations)) {
+        const block = convertToFunctionBody(updated);
+        const statements = mergeLexicalEnvironment(block.statements, declarations);
+        return updateBlock(block, statements);
+    }
+    return updated;
+}
+export function visitEachChild(node, visitor, context, nodesVisitor = visitNodes, tokenVisitor) {
+    if (node === undefined) {
+        return undefined;
+    }
+    const kind = node.kind;
+    // O token não tem filho a visitar.
+    if (kind > 0 /* SyntaxKind.FirstToken */ && kind <= 152 /* SyntaxKind.LastToken */) {
+        return node;
+    }
+    switch (kind) {
+        // Names
+        case 75 /* SyntaxKind.Identifier */:
+            return updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, isTypeNodeOrTypeParameterDeclaration));
+        case 153 /* SyntaxKind.QualifiedName */:
+            return updateQualifiedName(node, visitNode(node.left, visitor, isEntityName), visitNode(node.right, visitor, isIdentifier));
+        case 154 /* SyntaxKind.ComputedPropertyName */:
+            return updateComputedPropertyName(node, visitNode(node.expression, visitor, isExpression));
+        // Signature elements
+        case 155 /* SyntaxKind.TypeParameter */:
+            return updateTypeParameterDeclaration(node, visitNode(node.name, visitor, isIdentifier), visitNode(node.constraint, visitor, isTypeNode), visitNode(node.default, visitor, isTypeNode));
+        case 156 /* SyntaxKind.Parameter */:
+            return updateParameter(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.dotDotDotToken, tokenVisitor, isToken), visitNode(node.name, visitor, isBindingName), visitNode(node.questionToken, tokenVisitor, isToken), visitNode(node.type, visitor, isTypeNode), visitNode(node.initializer, visitor, isExpression));
+        // Type elements
+        case 158 /* SyntaxKind.PropertySignature */:
+            return updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, isToken), visitNode(node.name, visitor, isPropertyName), visitNode(node.questionToken, tokenVisitor, isToken), visitNode(node.type, visitor, isTypeNode), visitNode(node.initializer, visitor, isExpression));
+        case 160 /* SyntaxKind.MethodSignature */:
+            return updateMethodSignature(node, nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, isParameterDeclaration), visitNode(node.type, visitor, isTypeNode), visitNode(node.name, visitor, isPropertyName), visitNode(node.questionToken, tokenVisitor, isToken));
+        case 165 /* SyntaxKind.CallSignature */:
+            return updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, isParameterDeclaration), visitNode(node.type, visitor, isTypeNode));
+        case 167 /* SyntaxKind.IndexSignature */:
+            return updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, isModifier), nodesVisitor(node.parameters, visitor, isParameterDeclaration), visitNode(node.type, visitor, isTypeNode));
+        // Types
+        case 168 /* SyntaxKind.TypePredicate */:
+            return updateTypePredicateNodeWithModifier(node, visitNode(node.assertsModifier, visitor), visitNode(node.parameterName, visitor), visitNode(node.type, visitor, isTypeNode));
+        case 169 /* SyntaxKind.TypeReference */:
+            return updateTypeReferenceNode(node, visitNode(node.typeName, visitor, isEntityName), nodesVisitor(node.typeArguments, visitor, isTypeNode));
+        case 170 /* SyntaxKind.FunctionType */:
+            return updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, isParameterDeclaration), visitNode(node.type, visitor, isTypeNode));
+        case 172 /* SyntaxKind.TypeQuery */:
+            return updateTypeQueryNode(node, visitNode(node.exprName, visitor, isEntityName));
+        case 173 /* SyntaxKind.TypeLiteral */:
+            return updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, isTypeElement));
+        case 174 /* SyntaxKind.ArrayType */:
+            return updateArrayTypeNode(node, visitNode(node.elementType, visitor, isTypeNode));
+        case 175 /* SyntaxKind.TupleType */:
+            return updateTupleTypeNode(node, nodesVisitor(node.elementTypes, visitor, isTypeNode));
+        case 176 /* SyntaxKind.OptionalType */:
+            return updateOptionalTypeNode(node, visitNode(node.type, visitor, isTypeNode));
+        case 177 /* SyntaxKind.RestType */:
+            return updateRestTypeNode(node, visitNode(node.type, visitor, isTypeNode));
+        case 178 /* SyntaxKind.UnionType */:
+            return updateUnionTypeNode(node, nodesVisitor(node.types, visitor, isTypeNode));
+        case 179 /* SyntaxKind.IntersectionType */:
+            return updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, isTypeNode));
+        case 180 /* SyntaxKind.ConditionalType */:
+            return updateConditionalTypeNode(node, visitNode(node.checkType, visitor, isTypeNode), visitNode(node.extendsType, visitor, isTypeNode), visitNode(node.trueType, visitor, isTypeNode), visitNode(node.falseType, visitor, isTypeNode));
+        case 181 /* SyntaxKind.InferType */:
+            return updateInferTypeNode(node, visitNode(node.typeParameter, visitor, isTypeParameterDeclaration));
+        case 188 /* SyntaxKind.ImportType */:
+            return updateImportTypeNode(node, visitNode(node.argument, visitor, isTypeNode), visitNode(node.qualifier, visitor, isEntityName), visitNodes(node.typeArguments, visitor, isTypeNode), node.isTypeOf);
+        case 182 /* SyntaxKind.ParenthesizedType */:
+            return updateParenthesizedType(node, visitNode(node.type, visitor, isTypeNode));
+        case 184 /* SyntaxKind.TypeOperator */:
+            return updateTypeOperatorNode(node, visitNode(node.type, visitor, isTypeNode));
+        case 185 /* SyntaxKind.IndexedAccessType */:
+            return updateIndexedAccessTypeNode(node, visitNode(node.objectType, visitor, isTypeNode), visitNode(node.indexType, visitor, isTypeNode));
+        case 186 /* SyntaxKind.MappedType */:
+            return updateMappedTypeNode(node, visitNode(node.readonlyToken, tokenVisitor, isToken), visitNode(node.typeParameter, visitor, isTypeParameterDeclaration), visitNode(node.questionToken, tokenVisitor, isToken), visitNode(node.type, visitor, isTypeNode));
+        case 187 /* SyntaxKind.LiteralType */:
+            return updateLiteralTypeNode(node, visitNode(node.literal, visitor, isExpression));
+        // Binding patterns
+        case 189 /* SyntaxKind.ObjectBindingPattern */:
+            return updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, isBindingElement));
+        case 190 /* SyntaxKind.ArrayBindingPattern */:
+            return updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, isArrayBindingElement));
+        case 191 /* SyntaxKind.BindingElement */:
+            return updateBindingElement(node, visitNode(node.dotDotDotToken, tokenVisitor, isToken), visitNode(node.propertyName, visitor, isPropertyName), visitNode(node.name, visitor, isBindingName), visitNode(node.initializer, visitor, isExpression));
+        // Expression
+        case 192 /* SyntaxKind.ArrayLiteralExpression */:
+            return updateArrayLiteral(node, nodesVisitor(node.elements, visitor, isExpression));
+        case 193 /* SyntaxKind.ObjectLiteralExpression */:
+            return updateObjectLiteral(node, nodesVisitor(node.properties, visitor, isObjectLiteralElementLike));
+        case 194 /* SyntaxKind.PropertyAccessExpression */:
+            if (node.flags & 32 /* NodeFlags.OptionalChain */) {
+                return updatePropertyAccessChain(node, visitNode(node.expression, visitor, isExpression), visitNode(node.questionDotToken, tokenVisitor, isToken), visitNode(node.name, visitor, isIdentifier));
+            }
+            return updatePropertyAccess(node, visitNode(node.expression, visitor, isExpression), visitNode(node.name, visitor, isIdentifier));
+        case 195 /* SyntaxKind.ElementAccessExpression */:
+            if (node.flags & 32 /* NodeFlags.OptionalChain */) {
+                return updateElementAccessChain(node, visitNode(node.expression, visitor, isExpression), visitNode(node.questionDotToken, tokenVisitor, isToken), visitNode(node.argumentExpression, visitor, isExpression));
+            }
+            return updateElementAccess(node, visitNode(node.expression, visitor, isExpression), visitNode(node.argumentExpression, visitor, isExpression));
+        case 196 /* SyntaxKind.CallExpression */:
+            if (node.flags & 32 /* NodeFlags.OptionalChain */) {
+                return updateCallChain(node, visitNode(node.expression, visitor, isExpression), visitNode(node.questionDotToken, tokenVisitor, isToken), nodesVisitor(node.typeArguments, visitor, isTypeNode), nodesVisitor(node.arguments, visitor, isExpression));
+            }
+            return updateCall(node, visitNode(node.expression, visitor, isExpression), nodesVisitor(node.typeArguments, visitor, isTypeNode), nodesVisitor(node.arguments, visitor, isExpression));
+        case 200 /* SyntaxKind.ParenthesizedExpression */:
+            return updateParen(node, visitNode(node.expression, visitor, isExpression));
+        case 202 /* SyntaxKind.ArrowFunction */:
+            return updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, isModifier), nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitNode(node.type, visitor, isTypeNode), visitNode(node.equalsGreaterThanToken, tokenVisitor, isToken), visitFunctionBody(node.body, visitor, context));
+        case 203 /* SyntaxKind.DeleteExpression */:
+            return updateDelete(node, visitNode(node.expression, visitor, isExpression));
+        case 204 /* SyntaxKind.TypeOfExpression */:
+            return updateTypeOf(node, visitNode(node.expression, visitor, isExpression));
+        case 206 /* SyntaxKind.AwaitExpression */:
+            return updateAwait(node, visitNode(node.expression, visitor, isExpression));
+        case 207 /* SyntaxKind.PrefixUnaryExpression */:
+            return updatePrefix(node, visitNode(node.operand, visitor, isExpression));
+        case 208 /* SyntaxKind.PostfixUnaryExpression */:
+            return updatePostfix(node, visitNode(node.operand, visitor, isExpression));
+        case 209 /* SyntaxKind.BinaryExpression */:
+            return updateBinary(node, visitNode(node.left, visitor, isExpression), visitNode(node.right, visitor, isExpression), visitNode(node.operatorToken, tokenVisitor, isToken));
+        case 210 /* SyntaxKind.ConditionalExpression */:
+            return updateConditional(node, visitNode(node.condition, visitor, isExpression), visitNode(node.questionToken, tokenVisitor, isToken), visitNode(node.whenTrue, visitor, isExpression), visitNode(node.colonToken, tokenVisitor, isToken), visitNode(node.whenFalse, visitor, isExpression));
+        case 211 /* SyntaxKind.TemplateExpression */:
+            return updateTemplateExpression(node, visitNode(node.head, visitor, isTemplateHead), nodesVisitor(node.templateSpans, visitor, isTemplateSpan));
+        case 213 /* SyntaxKind.SpreadElement */:
+            return updateSpread(node, visitNode(node.expression, visitor, isExpression));
+        case 217 /* SyntaxKind.AsExpression */:
+            return updateAsExpression(node, visitNode(node.expression, visitor, isExpression), visitNode(node.type, visitor, isTypeNode));
+        case 219 /* SyntaxKind.MetaProperty */:
+            return updateMetaProperty(node, visitNode(node.name, visitor, isIdentifier));
+        // Misc
+        case 221 /* SyntaxKind.TemplateSpan */:
+            return updateTemplateSpan(node, visitNode(node.expression, visitor, isExpression), visitNode(node.literal, visitor, isTemplateMiddleOrTemplateTail));
+        // Element
+        case 223 /* SyntaxKind.Block */:
+            return updateBlock(node, nodesVisitor(node.statements, visitor, isStatement));
+        case 225 /* SyntaxKind.VariableStatement */:
+            return updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.declarationList, visitor, isVariableDeclarationList));
+        case 226 /* SyntaxKind.ExpressionStatement */:
+            return updateExpressionStatement(node, visitNode(node.expression, visitor, isExpression));
+        case 227 /* SyntaxKind.IfStatement */:
+            return updateIf(node, visitNode(node.expression, visitor, isExpression), visitNode(node.thenStatement, visitor, isStatement, liftToBlock), visitNode(node.elseStatement, visitor, isStatement, liftToBlock));
+        case 228 /* SyntaxKind.DoStatement */:
+            return updateDo(node, visitNode(node.statement, visitor, isStatement, liftToBlock), visitNode(node.expression, visitor, isExpression));
+        case 229 /* SyntaxKind.WhileStatement */:
+            return updateWhile(node, visitNode(node.expression, visitor, isExpression), visitNode(node.statement, visitor, isStatement, liftToBlock));
+        case 230 /* SyntaxKind.ForStatement */:
+            return updateFor(node, visitNode(node.initializer, visitor, isForInitializer), visitNode(node.condition, visitor, isExpression), visitNode(node.incrementor, visitor, isExpression), visitNode(node.statement, visitor, isStatement, liftToBlock));
+        case 231 /* SyntaxKind.ForInStatement */:
+            return updateForIn(node, visitNode(node.initializer, visitor, isForInitializer), visitNode(node.expression, visitor, isExpression), visitNode(node.statement, visitor, isStatement, liftToBlock));
+        case 232 /* SyntaxKind.ForOfStatement */:
+            return updateForOf(node, visitNode(node.awaitModifier, tokenVisitor, isToken), visitNode(node.initializer, visitor, isForInitializer), visitNode(node.expression, visitor, isExpression), visitNode(node.statement, visitor, isStatement, liftToBlock));
+        case 235 /* SyntaxKind.ReturnStatement */:
+            return updateReturn(node, visitNode(node.expression, visitor, isExpression));
+        case 237 /* SyntaxKind.SwitchStatement */:
+            return updateSwitch(node, visitNode(node.expression, visitor, isExpression), visitNode(node.caseBlock, visitor, isCaseBlock));
+        case 239 /* SyntaxKind.ThrowStatement */:
+            return updateThrow(node, visitNode(node.expression, visitor, isExpression));
+        case 240 /* SyntaxKind.TryStatement */:
+            return updateTry(node, visitNode(node.tryBlock, visitor, isBlock), visitNode(node.catchClause, visitor, isCatchClause), visitNode(node.finallyBlock, visitor, isBlock));
+        case 242 /* SyntaxKind.VariableDeclaration */:
+            return updateTypeScriptVariableDeclaration(node, visitNode(node.name, visitor, isBindingName), visitNode(node.exclamationToken, tokenVisitor, isToken), visitNode(node.type, visitor, isTypeNode), visitNode(node.initializer, visitor, isExpression));
+        case 243 /* SyntaxKind.VariableDeclarationList */:
+            return updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, isVariableDeclaration));
+        case 247 /* SyntaxKind.TypeAliasDeclaration */:
+            return updateTypeAliasDeclaration(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.name, visitor, isIdentifier), nodesVisitor(node.typeParameters, visitor, isTypeParameterDeclaration), visitNode(node.type, visitor, isTypeNode));
+        case 249 /* SyntaxKind.ModuleDeclaration */:
+            return updateModuleDeclaration(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.name, visitor, isIdentifier), visitNode(node.body, visitor, isModuleBody));
+        case 250 /* SyntaxKind.ModuleBlock */:
+            return updateModuleBlock(node, nodesVisitor(node.statements, visitor, isStatement));
+        case 251 /* SyntaxKind.CaseBlock */:
+            return updateCaseBlock(node, nodesVisitor(node.clauses, visitor, isCaseOrDefaultClause));
+        case 254 /* SyntaxKind.ImportDeclaration */:
+            return updateImportDeclaration(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.importClause, visitor, isImportClause), visitNode(node.moduleSpecifier, visitor, isExpression));
+        case 255 /* SyntaxKind.ImportClause */:
+            return updateImportClause(node, visitNode(node.name, visitor, isIdentifier), visitNode(node.namedBindings, visitor, isNamedImportBindings), node.isTypeOnly);
+        case 256 /* SyntaxKind.NamespaceImport */:
+            return updateNamespaceImport(node, visitNode(node.name, visitor, isIdentifier));
+        case 262 /* SyntaxKind.NamespaceExport */:
+            return updateNamespaceExport(node, visitNode(node.name, visitor, isIdentifier));
+        case 257 /* SyntaxKind.NamedImports */:
+            return updateNamedImports(node, nodesVisitor(node.elements, visitor, isImportSpecifier));
+        case 258 /* SyntaxKind.ImportSpecifier */:
+            return updateImportSpecifier(node, visitNode(node.propertyName, visitor, isIdentifier), visitNode(node.name, visitor, isIdentifier));
+        case 259 /* SyntaxKind.ExportAssignment */:
+            return updateExportAssignment(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.expression, visitor, isExpression));
+        case 260 /* SyntaxKind.ExportDeclaration */:
+            return updateExportDeclaration(node, nodesVisitor(node.modifiers, visitor, isModifier), visitNode(node.exportClause, visitor, isNamedExportBindings), visitNode(node.moduleSpecifier, visitor, isExpression), node.isTypeOnly);
+        case 261 /* SyntaxKind.NamedExports */:
+            return updateNamedExports(node, nodesVisitor(node.elements, visitor, isExportSpecifier));
+        case 263 /* SyntaxKind.ExportSpecifier */:
+            return updateExportSpecifier(node, visitNode(node.propertyName, visitor, isIdentifier), visitNode(node.name, visitor, isIdentifier));
+        // JSX
+        case 266 /* SyntaxKind.JsxElement */:
+            return updateJsxElement(node, visitNode(node.openingElement, visitor, isJsxOpeningElement), nodesVisitor(node.children, visitor, isJsxChild), visitNode(node.closingElement, visitor, isJsxClosingElement));
+        case 267 /* SyntaxKind.JsxSelfClosingElement */:
+            return updateJsxSelfClosingElement(node, visitNode(node.tagName, visitor, isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, isTypeNode), visitNode(node.attributes, visitor, isJsxAttributes));
+        case 268 /* SyntaxKind.JsxOpeningElement */:
+            return updateJsxOpeningElement(node, visitNode(node.tagName, visitor, isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, isTypeNode), visitNode(node.attributes, visitor, isJsxAttributes));
+        case 269 /* SyntaxKind.JsxClosingElement */:
+            return updateJsxClosingElement(node, visitNode(node.tagName, visitor, isJsxTagNameExpression));
+        case 270 /* SyntaxKind.JsxFragment */:
+            return updateJsxFragment(node, visitNode(node.openingFragment, visitor, isJsxOpeningFragment), nodesVisitor(node.children, visitor, isJsxChild), visitNode(node.closingFragment, visitor, isJsxClosingFragment));
+        case 273 /* SyntaxKind.JsxAttribute */:
+            return updateJsxAttribute(node, visitNode(node.name, visitor, isIdentifier), visitNode(node.initializer, visitor, isStringLiteralOrJsxExpression));
+        case 274 /* SyntaxKind.JsxAttributes */:
+            return updateJsxAttributes(node, nodesVisitor(node.properties, visitor, isJsxAttributeLike));
+        case 275 /* SyntaxKind.JsxSpreadAttribute */:
+            return updateJsxSpreadAttribute(node, visitNode(node.expression, visitor, isExpression));
+        case 276 /* SyntaxKind.JsxExpression */:
+            return updateJsxExpression(node, visitNode(node.expression, visitor, isExpression));
+        // Clauses
+        case 277 /* SyntaxKind.CaseClause */:
+            return updateCaseClause(node, visitNode(node.expression, visitor, isExpression), nodesVisitor(node.statements, visitor, isStatement));
+        case 278 /* SyntaxKind.DefaultClause */:
+            return updateDefaultClause(node, nodesVisitor(node.statements, visitor, isStatement));
+        case 280 /* SyntaxKind.CatchClause */:
+            return updateCatchClause(node, visitNode(node.variableDeclaration, visitor, isVariableDeclaration), visitNode(node.block, visitor, isBlock));
+        // Property assignments
+        case 281 /* SyntaxKind.PropertyAssignment */:
+            return updatePropertyAssignment(node, visitNode(node.name, visitor, isPropertyName), visitNode(node.initializer, visitor, isExpression));
+        case 282 /* SyntaxKind.ShorthandPropertyAssignment */:
+            return updateShorthandPropertyAssignment(node, visitNode(node.name, visitor, isIdentifier), visitNode(node.objectAssignmentInitializer, visitor, isExpression));
+        case 283 /* SyntaxKind.SpreadAssignment */:
+            return updateSpreadAssignment(node, visitNode(node.expression, visitor, isExpression));
+        // Top-level nodes
+        case 290 /* SyntaxKind.SourceFile */:
+            return updateSourceFileNode(node, visitLexicalEnvironment(node.statements, visitor, context));
+        // Transformation nodes
+        case 326 /* SyntaxKind.PartiallyEmittedExpression */:
+            return updatePartiallyEmittedExpression(node, visitNode(node.expression, visitor, isExpression));
+        case 327 /* SyntaxKind.CommaListExpression */:
+            return updateCommaList(node, nodesVisitor(node.elements, visitor, isExpression));
+        default:
+            // No need to visit nodes with no children.
+            return node;
+    }
+}
+/**
+ * Extracts the single node from a NodeArray.
+ *
+ * @param nodes The NodeArray.
+ */
+function extractSingleNode(nodes) {
+    Debug.assert(nodes.length <= 1, "Too many nodes written to output.");
+    return singleOrUndefined(nodes);
+}

package/package.json

@@ -1,64 +1,36 @@
 {
   "name": "@tslite/parser",
-  "version": "1.10.0",
-  "description": "TSLite parser — tokenizer + Pratt parser for the TSLite language (JS subset + pipe) into ESTree",
+  "version": "1.12.0",
+  "description": "The tsc 3.9.10 parse tree, copied from the tag and cut down to the TSLite Language: the tree model, the scanner, the parser and the tree vocabulary",
+  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
+  "license": "Apache-2.0",
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "types": "./dist/_namespaces/ts.d.ts",
+      "import": "./dist/_namespaces/ts.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE",
+    "NOTICE"
   ],
-  "sideEffects": false,
-  "engines": {
-    "node": ">=18"
+  "dependencies": {
+    "@types/microsoft__typescript-etw": "^0.1.3"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/andersondrosa/tslite.git",
     "directory": "packages/parser"
   },
-  "keywords": [
-    "ast",
-    "estree",
-    "tokenizer",
-    "lexer",
-    "parser",
-    "pratt",
-    "typescript"
-  ],
-  "author": "Anderson D. Rosa <andersondrosa@outlook.com>",
-  "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@tslite/ast": "^1.5.0"
-  },
-  "devDependencies": {
-    "@tslite/checker": "1.9.0",
-    "@tslite/interpret": "1.5.0",
-    "@tslite/codegen": "1.5.0",
-    "@tslite/capability": "1.4.0"
-  },
   "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src tests",
-    "lint:fix": "eslint src tests --fix",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && node ../../scripts/copy-declarations.mjs dist",
     "clean": "rm -rf dist",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "format:check": "prettier --check \"src/**/*.ts\""
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit -p ."
   }
 }