@danielblomma/cortex-mcp 2.1.4 → 2.2.1

package/scaffold/scripts/parsers/node_modules/acorn-typescript/lib/index.d.ts

@@ -1,472 +0,0 @@
-import * as acornNamespace from 'acorn';
-import { Accessibility, LookaheadState, ModifierBase, ParsingContext, TryParse, TsModifier } from './types';
-import { DestructuringErrors } from './parseutil';
-import { AcornParseClass } from './middleware';
-import { Node, TokenType, Position, Options } from 'acorn';
-declare function tsPlugin(options?: {
-    dts?: boolean;
-    jsx?: {
-        allowNamespaces?: boolean;
-        allowNamespacedObjects?: boolean;
-    };
-    allowSatisfies?: boolean;
-}): (Parser: typeof AcornParseClass) => {
-    new (options: Options, input: string, startPos?: number): {
-        preValue: any;
-        preToken: any;
-        isLookahead: boolean;
-        isAmbientContext: boolean;
-        inAbstractClass: boolean;
-        inType: boolean;
-        inDisallowConditionalTypesContext: boolean;
-        maybeInArrowParameters: boolean;
-        shouldParseArrowReturnType: any | undefined;
-        shouldParseAsyncArrowReturnType: any | undefined;
-        decoratorStack: any[];
-        importsStack: any[];
-        /**
-         * we will only parse one import node or export node at same time.
-         * default kind is undefined
-         * */
-        importOrExportOuterKind: string | undefined;
-        tsParseConstModifier: any;
-        readonly acornTypeScript: import("./types").AcornTypeScript;
-        getTokenFromCodeInType(code: number): TokenType;
-        readToken(code: number): any;
-        getTokenFromCode(code: number): TokenType;
-        isAbstractClass(): boolean;
-        finishNode(node: any, type: string): any;
-        tryParse<T extends acornNamespace.Node | readonly acornNamespace.Node[]>(fn: (abort: (node?: T) => never) => T, oldState?: LookaheadState): TryParse<T, null, false, false, null> | TryParse<T, SyntaxError, boolean, false, LookaheadState> | TryParse<T, null, false, true, LookaheadState>;
-        setOptionalParametersError(refExpressionErrors: any, resultError?: any): void;
-        reScan_lt_gt(): void;
-        reScan_lt(): acornNamespace.TokenType;
-        resetEndLocation(node: any, endLoc?: Position): void;
-        startNodeAtNode(type: Node): any;
-        nextTokenStart(): number;
-        tsHasSomeModifiers(member: any, modifiers: readonly TsModifier[]): boolean;
-        tsIsStartOfStaticBlocks(): boolean;
-        tsCheckForInvalidTypeCasts(items: Array<undefined | null | any>): void;
-        atPossibleAsyncArrow(base: any): boolean;
-        tsIsIdentifier(): boolean;
-        tsTryParseTypeOrTypePredicateAnnotation(): acornNamespace.Node;
-        tsTryParseGenericAsyncArrowFunction(startPos: number, startLoc: Position, forInit: boolean): any | undefined | null;
-        tsParseTypeArgumentsInExpression(): Node | void;
-        tsInNoContext<T_1>(cb: () => T_1): T_1;
-        tsTryParseTypeAnnotation(): Node | undefined | null;
-        isUnparsedContextual(nameStart: number, name: string): boolean;
-        isAbstractConstructorSignature(): boolean;
-        nextTokenStartSince(pos: number): number;
-        lookaheadCharCode(): number;
-        compareLookaheadState(state: LookaheadState, state2: LookaheadState): boolean;
-        createLookaheadState(): void;
-        getCurLookaheadState(): LookaheadState;
-        cloneCurLookaheadState(): LookaheadState;
-        setLookaheadState(state: LookaheadState): void;
-        tsLookAhead<T_2>(f: () => T_2): T_2;
-        lookahead(number?: number): LookaheadState;
-        readWord(): any;
-        skipBlockComment(): void;
-        skipLineComment(startSkip: any): void;
-        finishToken(type: TokenType, val?: string): any;
-        resetStartLocation(node: Node, start: number, startLoc: Position): void;
-        isLineTerminator(): boolean;
-        hasFollowingLineBreak(): boolean;
-        addExtra(node: any, key: string, value: any, enumerable?: boolean): void;
-        /**
-         * Test if current token is a literal property name
-         * https://tc39.es/ecma262/#prod-LiteralPropertyName
-         * LiteralPropertyName:
-         *   IdentifierName
-         *   StringLiteral
-         *   NumericLiteral
-         *   BigIntLiteral
-         */
-        isLiteralPropertyName(): boolean;
-        hasPrecedingLineBreak(): boolean;
-        createIdentifier(node: Omit<any, 'type'>, name: string): any;
-        /**
-         * Reset the start location of node to the start location of locationNode
-         */
-        resetStartLocationFromNode(node: Node, locationNode: Node): void;
-        isThisParam(param: any): boolean;
-        isLookaheadContextual(name: string): boolean;
-        /**
-         * ts type isContextual
-         * @param {TokenType} type
-         * @param {TokenType} token
-         * @returns {boolean}
-         * */
-        ts_type_isContextual(type: TokenType, token: TokenType): boolean;
-        /**
-         * ts isContextual
-         * @param {TokenType} token
-         * @returns {boolean}
-         * */
-        ts_isContextual(token: TokenType): boolean;
-        ts_isContextualWithState(state: LookaheadState, token: TokenType): boolean;
-        isContextualWithState(keyword: string, state: LookaheadState): boolean;
-        tsIsStartOfMappedType(): boolean;
-        tsInDisallowConditionalTypesContext<T_3>(cb: () => T_3): T_3;
-        tsTryParseType(): Node | undefined | null;
-        /**
-         * Whether current token matches given type
-         *
-         * @param {TokenType} type
-         * @returns {boolean}
-         * @memberof Tokenizer
-         */
-        match(type: TokenType): boolean;
-        matchJsx(type: string): boolean;
-        ts_eatWithState(type: TokenType, nextCount: number, state: LookaheadState): boolean;
-        ts_eatContextualWithState(name: string, nextCount: number, state: LookaheadState): boolean;
-        canHaveLeadingDecorator(): boolean;
-        eatContextual(name: string): boolean;
-        tsIsExternalModuleReference(): boolean;
-        tsParseExternalModuleReference(): any;
-        tsParseEntityName(allowReservedWords?: boolean): Node;
-        tsParseEnumMember(): Node;
-        tsParseEnumDeclaration(node: any, properties?: {
-            const?: true;
-            declare?: true;
-        }): any;
-        tsParseModuleBlock(): Node;
-        tsParseAmbientExternalModuleDeclaration(node: any): any;
-        tsTryParseDeclare(nany: any): any | undefined | null;
-        tsIsListTerminator(kind: any): boolean;
-        /**
-         * If !expectSuccess, returns undefined instead of failing to parse.
-         * If expectSuccess, parseElement should always return a defined value.
-         */
-        tsParseDelimitedListWorker<T_4 extends acornNamespace.Node>(kind: any, parseElement: () => T_4, expectSuccess: boolean, refTrailingCommaPos?: {
-            value: number;
-        }): T_4[];
-        tsParseDelimitedList<T_5 extends acornNamespace.Node>(kind: any, parseElement: () => T_5, refTrailingCommaPos?: {
-            value: number;
-        }): T_5[];
-        tsParseBracketedList<T_6 extends acornNamespace.Node>(kind: any, parseElement: () => T_6, bracket: boolean, skipFirstToken: boolean, refTrailingCommaPos?: {
-            value: number;
-        }): T_6[];
-        tsParseTypeParameterName(): any | string;
-        tsEatThenParseType(token: TokenType): Node | typeof undefined;
-        tsExpectThenParseType(token: TokenType): Node;
-        tsNextThenParseType(): Node;
-        tsDoThenParseType(cb: () => void): Node;
-        tsSkipParameterStart(): boolean;
-        tsIsUnambiguouslyStartOfFunctionType(): boolean;
-        tsIsStartOfFunctionType(): unknown;
-        tsInAllowConditionalTypesContext<T_7>(cb: () => T_7): T_7;
-        tsParseBindingListForSignature(): Array<any>;
-        tsParseTypePredicateAsserts(): boolean;
-        tsParseThisTypeNode(): any;
-        tsParseTypeAnnotation(eatColon?: boolean, t?: any): any;
-        tsParseThisTypePredicate(lhs: any): any;
-        tsParseThisTypeOrThisTypePredicate(): any;
-        tsParseTypePredicatePrefix(): any | undefined | null;
-        tsParseTypeOrTypePredicateAnnotation(returnToken: TokenType): Node;
-        tsFillSignature(returnToken: TokenType, signature: any): void;
-        tsTryNextParseConstantContext(): Node | undefined | null;
-        tsParseFunctionOrConstructorType(type: 'TSFunctionType' | 'TSConstructorType', abstract?: boolean): any;
-        tsParseUnionOrIntersectionType(kind: 'TSUnionType' | 'TSIntersectionType', parseConstituentType: () => Node, operator: TokenType): Node;
-        tsCheckTypeAnnotationForReadOnly(node: any): void;
-        tsParseTypeOperator(): any;
-        tsParseConstraintForInferType(): any;
-        tsParseInferType(): any;
-        tsParseLiteralTypeNode(): any;
-        tsParseImportType(): any;
-        tsParseTypeQuery(): any;
-        tsParseMappedTypeParameter(): any;
-        tsParseMappedType(): any;
-        tsParseTypeLiteral(): Node;
-        tsParseTupleElementType(): any;
-        tsParseTupleType(): any;
-        tsParseTemplateLiteralType(): any;
-        tsParseTypeReference(): any;
-        tsMatchLeftRelational(): boolean;
-        tsMatchRightRelational(): boolean;
-        tsParseParenthesizedType(): any;
-        tsParseNonArrayType(): Node;
-        tsParseArrayTypeOrHigher(): Node;
-        tsParseTypeOperatorOrHigher(): Node;
-        tsParseIntersectionTypeOrHigher(): Node;
-        tsParseUnionTypeOrHigher(): acornNamespace.Node;
-        tsParseNonConditionalType(): any;
-        /** Be sure to be in a type context before calling this, using `tsInType`. */
-        tsParseType(): any;
-        tsIsUnambiguouslyIndexSignature(): boolean;
-        /**
-         * Runs `cb` in a type context.
-         * This should be called one token *before* the first type token,
-         * so that the call to `next()` is run in type context.
-         */
-        tsInType<T_8>(cb: () => T_8): T_8;
-        tsTryParseIndexSignature(node: any): any | undefined | null;
-        tsParseNoneModifiers(node: any): void;
-        tsParseTypeParameter(parseModifiers?: (node: Node) => void): Node;
-        tsParseTypeParameters(parseModifiers?: (node: any) => void): any;
-        tsTryParseTypeParameters(parseModifiers?: (node: any) => void): any;
-        tsTryParse<T_9>(f: () => false | T_9): T_9;
-        tsTokenCanFollowModifier(): boolean;
-        tsNextTokenCanFollowModifier(): boolean;
-        /** Parses a modifier matching one the given modifier names. */
-        tsParseModifier<T_10 extends TsModifier>(allowedModifiers: T_10[], stopOnStartOfClassStaticBlock?: boolean): T_10;
-        tsParseModifiersByMap({ modified, map }: {
-            modified: ModifierBase;
-            map: Record<string, any>;
-        }): void;
-        /** Parses a list of modifiers, in any order.
-         *  If you need a specific order, you must call this function multiple times:
-         *    this.tsParseModifiers({ modified: node, allowedModifiers: ['public'] });
-         *    this.tsParseModifiers({ modified: node, allowedModifiers: ["abstract", "readonly"] });
-         */
-        tsParseModifiers({ modified, allowedModifiers, disallowedModifiers, stopOnStartOfClassStaticBlock, errorTemplate }: {
-            modified: ModifierBase;
-            allowedModifiers: readonly TsModifier[];
-            disallowedModifiers?: TsModifier[];
-            stopOnStartOfClassStaticBlock?: boolean;
-            errorTemplate?: any;
-        }): Record<string, any>;
-        tsParseInOutModifiers(node: any): void;
-        tsParseTypeArguments(): any;
-        tsParseHeritageClause(token: 'extends' | 'implements'): Array<any>;
-        tsParseTypeMemberSemicolon(): void;
-        tsTryParseAndCatch<T_11 extends unknown>(f: () => T_11): T_11;
-        tsParseSignatureMember(kind: 'TSCallSignatureDeclaration' | 'TSConstructSignatureDeclaration', node: Node): Node;
-        tsParsePropertyOrMethodSignature(node: any, readonly: boolean): any;
-        tsParseTypeMember(): any;
-        tsParseList<T_12 extends acornNamespace.Node>(kind: ParsingContext, parseElement: () => T_12): T_12[];
-        tsParseObjectTypeMembers(): Array<Node>;
-        tsParseInterfaceDeclaration(node: any, properties?: {
-            declare?: true;
-        }): any | undefined | null;
-        tsParseAbstractDeclaration(node: any): any | undefined | null;
-        tsIsDeclarationStart(): boolean;
-        tsParseExpressionStatement(node: any, expr: any): any;
-        tsParseModuleReference(): any;
-        tsIsExportDefaultSpecifier(): boolean;
-        tsInAmbientContext<T_13>(cb: () => T_13): T_13;
-        tsCheckLineTerminator(next: boolean): boolean;
-        tsParseModuleOrNamespaceDeclaration(node: any, nested?: boolean): any;
-        checkLValSimple(expr: any, bindingType?: any, checkClashes?: any): any;
-        tsParseTypeAliasDeclaration(node: any): any;
-        tsParseDeclaration(node: any, value: string, next: boolean): any | undefined | null;
-        tsTryParseExportDeclaration(): any | undefined | null;
-        tsParseImportEqualsDeclaration(node: any, isExport?: boolean): Node;
-        isExportDefaultSpecifier(): boolean;
-        parseTemplate({ isTagged }?: {
-            isTagged?: boolean;
-        }): any;
-        parseFunction(node: any, statement?: number, allowExpressionBody?: boolean, isAsync?: boolean, forInit?: boolean): any;
-        parseFunctionBody(node: any, isArrowFunction?: boolean, isMethod?: boolean, forInit?: boolean, tsConfig?: {
-            isFunctionDeclaration?: boolean;
-            isClassMethod?: boolean;
-        }): any;
-        parseNew(): any;
-        parseExprOp(left: any, leftStartPos: number, leftStartLoc: Position, minPrec: number, forInit: boolean): any;
-        parseImportSpecifiers(): any[];
-        /**
-         * @param {Node} node this may be ImportDeclaration |
-         * TsImportEqualsDeclaration
-         * @returns AnyImport
-         * */
-        parseImport(node: any): any;
-        parseExportDefaultDeclaration(): any;
-        parseExportAllDeclaration(node: any, exports: any): any;
-        parseDynamicImport(node: any): any;
-        parseExport(node: any, exports: any): any;
-        checkExport(exports: any, name: any, _: any): void;
-        parseMaybeDefault(startPos?: number | null, startLoc?: Position | null, left?: any | null): any;
-        typeCastToParameter(node: any): any;
-        toAssignableList(exprList: any[], isBinding: boolean): any;
-        reportReservedArrowTypeParam(node: any): void;
-        parseExprAtom(refDestructuringErrors?: DestructuringErrors, forInit?: boolean, forNew?: boolean): any;
-        parseExprAtomDefault(): any;
-        parseIdentNode(): any;
-        parseVarStatement(node: any, kind: any, allowMissingInitializer?: boolean): any;
-        parseStatement(context: any, topLevel?: any, exports?: any): any;
-        parseAccessModifier(): Accessibility | undefined | null;
-        parsePostMemberNameModifiers(methodOrProp: any): void;
-        parseExpressionStatement(node: any, expr: any): any;
-        shouldParseExportStatement(): boolean;
-        parseConditional(expr: any, startPos: number, startLoc: Position, forInit?: boolean, refDestructuringErrors?: any): any;
-        parseMaybeConditional(forInit: any, refDestructuringErrors: any): any;
-        parseParenItem(node: any): any;
-        parseExportDeclaration(node: any): any | undefined | null;
-        parseClassId(node: any, isStatement: boolean | 'nullableID'): void;
-        parseClassPropertyAnnotation(node: any): void;
-        parseClassField(field: any): any;
-        parseClassMethod(method: any, isGenerator: any, isAsync: any, allowsDirectSuper: any): any;
-        isClassMethod(): boolean;
-        parseClassElement(constructorAllowsSuper: any): any;
-        isClassElementNameStart(): boolean;
-        parseClassSuper(node: any): void;
-        parseFunctionParams(node: any): void;
-        parseVarId(decl: any, kind: 'var' | 'let' | 'const'): void;
-        parseArrowExpression(node: any, params: any[], isAsync: boolean, forInit?: boolean): any;
-        parseMaybeAssignOrigin(forInit?: any, refDestructuringErrors?: any | null, afterLeftParse?: any): any;
-        parseMaybeAssign(forInit?: boolean, refExpressionErrors?: any | null, afterLeftParse?: any): any;
-        parseAssignableListItem(allowModifiers: boolean | undefined | null): any;
-        checkLValInnerPattern(expr: any, bindingType: number, checkClashes: any): void;
-        parseBindingListItem(param: any): any;
-        isAssignable(node: any, isBinding?: boolean): boolean;
-        toAssignable(node: any, isBinding?: boolean, refDestructuringErrors?: DestructuringErrors): any;
-        toAssignableParenthesizedExpression(node: any, isBinding: boolean, refDestructuringErrors: DestructuringErrors): void;
-        curPosition(): acornNamespace.Position;
-        parseBindingAtom(): any;
-        shouldParseArrow(exprList?: any): boolean;
-        parseParenArrowList(startPos: any, startLoc: any, exprList: any, forInit: any): any;
-        parseParenAndDistinguishExpression(canBeArrow: any, forInit: any): any;
-        parseTaggedTemplateExpression(base: any, startPos: number, startLoc: Position, optionalChainMember: boolean): any;
-        shouldParseAsyncArrow(): boolean;
-        parseSubscriptAsyncArrow(startPos: any, startLoc: any, exprList: any, forInit: any): any;
-        parseExprList(close: TokenType, allowTrailingComma?: any, allowEmpty?: any, refDestructuringErrors?: any): any[];
-        parseSubscript(base: any, startPos: any, startLoc: any, noCalls: any, maybeAsyncArrow: any, optionalChained: any, forInit: any): any;
-        parseGetterSetter(prop: any): void;
-        parseProperty(isPattern: any, refDestructuringErrors: any): any;
-        parseCatchClauseParam(): any;
-        parseClass(node: any, isStatement: boolean | 'nullableID'): any;
-        parseClassFunctionParams(): any;
-        parseMethod(isGenerator: boolean, isAsync?: boolean, allowDirectSuper?: boolean, inClassScope?: boolean, method?: any): any;
-        parseImportSpecifier(): any;
-        parseExportSpecifier(exports: any): any;
-        parseTypeOnlyImportExportSpecifier(node: any, isImport: boolean, isInTypeOnlyImportExport: boolean): void;
-        raiseCommonCheck(pos: number, message: string, recoverable: boolean): void;
-        raiseRecoverable(pos: number, message: string): void;
-        raise(pos: number, message: string): void;
-        updateContext(prevType: any): any;
-        jsx_parseOpeningElementAt(startPos: any, startLoc: any): any;
-        enterScope(flags: any): void;
-        exitScope(): void;
-        hasImport(name: string, allowShadow?: boolean): boolean;
-        maybeExportDefined(scope: any, name: string): void;
-        isRedeclaredInScope(scope: any, name: string, bindingType: any): boolean;
-        checkRedeclarationInScope(scope: any, name: string, bindingType: any, loc: any): void;
-        declareName(name: any, bindingType: any, pos: any): void;
-        checkLocalExport(id: any): void;
-        options: acornNamespace.Options & {
-            onComment: any;
-        };
-        pos: number;
-        potentialArrowAt: number;
-        yieldPos: number;
-        value: any;
-        containsEsc: boolean;
-        awaitPos: number;
-        keywords: any;
-        awaitIdentPos: number;
-        strict: boolean;
-        lastTokStart: number;
-        lastTokEnd: number;
-        treatFunctionsAsVar: boolean;
-        inGenerator: any;
-        exprAllowed: boolean;
-        labels: any[];
-        scopeStack: any[];
-        inModule: any;
-        undefinedExports: any;
-        lastTokEndLoc: any;
-        lastTokStartLoc: any;
-        context: any[];
-        endLoc: any;
-        startLoc: any;
-        potentialArrowInForAwait: boolean;
-        currentScope(): any;
-        treatFunctionsAsVarInScope(scope: any): boolean;
-        parseExportSpecifiers(exports: any): any[];
-        parseModuleExportName(): any;
-        expectContextual(name: string): any;
-        semicolon(): any;
-        eat(type: acornNamespace.TokenType): boolean;
-        unexpected(pos?: number): any;
-        startNode(): any;
-        startNodeAt(pos: number, loc: any): any;
-        isAsyncFunction(): boolean;
-        checkVariableExport(exports: any, decls: any): any;
-        checkUnreserved(options: {
-            start: number;
-            end: number;
-            name: string;
-        }): any;
-        finishOp(type: acornNamespace.TokenType, size: number): any;
-        readToken_lt_gt(code: number): acornNamespace.TokenType;
-        fullCharCodeAtPos(): number;
-        canInsertSemicolon(): boolean;
-        expect(type: acornNamespace.TokenType): void;
-        readWord1(): string;
-        curContext(): any;
-        isContextual(name: string): boolean;
-        parseLiteral(value: string): any;
-        parseFunctionStatement(node: any, isAsync?: boolean, declarationPosition?: any): any;
-        parseObj(isPattern?: boolean, refDestructuringErrors?: any): any;
-        parseBindingList(close: acornNamespace.TokenType, allowEmpty?: boolean, allowTrailingComma?: boolean, allowModifiers?: boolean): any;
-        parsePropertyName(prop: any): any;
-        isLet(context?: any): boolean;
-        parseTemplateElement({ isTagged }: {
-            isTagged: boolean;
-        }): any;
-        parseExpression(forInit?: boolean, refDestructuringErrors?: any): any;
-        initFunction(node: any): void;
-        parseSubscripts(base: any, startPos: number, startLoc: acornNamespace.Position, noCalls?: any, forInit?: any): any;
-        parseSpread(refDestructuringErrors: any): any;
-        parseMaybeUnary(refExpressionErrors?: any, sawUnary?: boolean, incDec?: boolean, forInit?: boolean): any;
-        readRegexp(): any;
-        overrideContext(ctx: any): any;
-        isSimpleAssignTarget(expr: any): boolean;
-        parseExprImport(forNew?: boolean): any;
-        next(ignoreEscapeSequenceInKeyword?: boolean): any;
-        parseExprOps(forInit?: boolean, refDestructuringErrors?: any): any;
-        checkExpressionErrors(refDestructuringErrors: any, andThrow?: boolean): any;
-        parseClassStaticBlock(node: any): any;
-        parseClassElementName(element: any): any;
-        checkPatternErrors(refDestructuringErrors?: any, isAssign?: boolean): any;
-        parseExprSubscripts(refDestructuringErrors?: any, forInit?: boolean): any;
-        checkYieldAwaitInDefaultParams(): any;
-        parseParenExpression(): any;
-        afterTrailingComma(tokType: acornNamespace.TokenType, notNext?: boolean): any;
-        parsePrivateIdent(): any;
-        parseRestBinding(): any;
-        parseBlock(createNewLexicalScope?: boolean, node?: any, exitStrict?: boolean): any;
-        enterClassBody(): any;
-        exitClassBody(): any;
-        parseVar(node: any, isFor: any, kind: any, allowMissingInitializer: any): any;
-        parseIdent(liberal?: boolean): any;
-        copyNode(node: any): any;
-        checkLValPattern(expr: any, bindingType?: number, checkClashes?: any): any;
-        isAsyncProp(prop: any): boolean;
-        parseYield(forInit?: any): any;
-        takeDecorators(node: any): void;
-        parseDecorators(allowExport?: boolean): void;
-        parseDecorator(): any;
-        parseMaybeDecoratorArguments(expr: any): any;
-        jsx_readToken(): any;
-        jsx_readString(quote: any): any;
-        jsx_parseText(): any;
-        jsx_parseElement(): any;
-        jsx_readWord(): any;
-        jsx_parseElementName(): any;
-        jsx_parseAttribute(): any;
-        parseImportDefaultSpecifier(): any;
-        parseImportNamespaceSpecifier(): any;
-        parseImportAttributes(): any;
-        parseMaybeImportAttributes(node: any): any;
-        lineStart: number;
-        curLine: number;
-        start: number;
-        end: number;
-        input: string;
-        type: acornNamespace.TokenType;
-        parse(this: acornNamespace.Parser): acornNamespace.Node;
-        nextToken(): void;
-        parseTopLevel(node: acornNamespace.Node): acornNamespace.Node;
-        finishNodeAt(node: acornNamespace.Node, type: string, pos: number, loc: acornNamespace.Position): acornNamespace.Node;
-    };
-    readonly acornTypeScript: import("./types").AcornTypeScript;
-    parse(input: string, options: Options): acornNamespace.Node;
-    parseExpressionAt(input: string, pos: number, options: Options): any;
-    acorn: typeof acornNamespace;
-    tokenizer(this: typeof acornNamespace.Parser, input: string, options: acornNamespace.Options): {
-        getToken(): acornNamespace.Token;
-        [Symbol.iterator](): Iterator<acornNamespace.Token, any, undefined>;
-    };
-    extend(this: typeof acornNamespace.Parser, ...plugins: ((BaseParser: typeof acornNamespace.Parser) => typeof acornNamespace.Parser)[]): typeof acornNamespace.Parser;
-};
-export { tsPlugin as default, tsPlugin };