xhs-mp-pack 1.1.0-beta.0

package/dist/module/javascript/JavascriptParser.d.ts

@@ -0,0 +1,598 @@
+import Parser from '@/module/Parser';
+declare const ALLOWED_MEMBER_TYPES_CALL_EXPRESSION = 1;
+declare const ALLOWED_MEMBER_TYPES_EXPRESSION = 2;
+declare const ALLOWED_MEMBER_TYPES_ALL = 3;
+declare class VariableInfo {
+    declaredScope: any;
+    freeName: string | boolean | undefined;
+    tagInfo: any;
+    constructor(declaredScope: any, freeName: string | boolean | undefined, tagInfo: any);
+}
+declare class JavascriptParser extends Parser {
+    hooks: any;
+    sourceType: string;
+    scope: any;
+    state: any;
+    comments: any;
+    semicolons: any;
+    statementPath: any;
+    prevStatement: any;
+    destructuringAssignmentProperties: any;
+    currentTagData: any;
+    constructor(sourceType?: string);
+    _initializeEvaluating(): void;
+    destructuringAssignmentPropertiesFor(node: any): any;
+    getRenameIdentifier(expr: any): any;
+    walkClass(classy: any): void;
+    /**
+     * Pre walking iterates the scope for variable declarations
+     *
+     * @param {(Statement | ModuleDeclaration)[]} statements statements
+     */
+    preWalkStatements(statements: any): void;
+    /**
+     * Block pre walking iterates the scope for block variable declarations
+     *
+     * @param {(Statement | ModuleDeclaration)[]} statements statements
+     */
+    blockPreWalkStatements(statements: any): void;
+    /**
+     * Walking iterates the statements and expressions and processes them
+     *
+     * @param {(Statement | ModuleDeclaration)[]} statements statements
+     */
+    walkStatements(statements: any): void;
+    /**
+     * Walking iterates the statements and expressions and processes them
+     *
+     * @param {Statement | ModuleDeclaration} statement statement
+     */
+    preWalkStatement(statement: any): void;
+    /**
+     * @param {Statement | ModuleDeclaration} statement statement
+     */
+    blockPreWalkStatement(statement: any): void;
+    /**
+     * @param {Statement | ModuleDeclaration} statement statement
+     */
+    walkStatement(statement: any): void;
+    /**
+     * Walks a statements that is nested within a parent statement
+     * and can potentially be a non-block statement.
+     * This enforces the nested statement to never be in ASI position.
+     *
+     * @param {Statement} statement the nested statement
+     */
+    walkNestedStatement(statement: any): void;
+    /**
+     * @param {BlockStatement} statement block statement
+     */
+    preWalkBlockStatement(statement: any): void;
+    /**
+     * @param {BlockStatement} statement block statement
+     */
+    walkBlockStatement(statement: any): void;
+    /**
+     * @param {ExpressionStatement} statement expression statement
+     */
+    walkExpressionStatement(statement: any): void;
+    /**
+     * @param {IfStatement} statement if statement
+     */
+    preWalkIfStatement(statement: any): void;
+    /**
+     * @param {IfStatement} statement if statement
+     */
+    walkIfStatement(statement: any): void;
+    /**
+     * @param {LabeledStatement} statement with statement
+     */
+    preWalkLabeledStatement(statement: any): void;
+    /**
+     * @param {LabeledStatement} statement with statement
+     */
+    walkLabeledStatement(statement: any): void;
+    /**
+     * @param {WithStatement} statement with statement
+     */
+    preWalkWithStatement(statement: any): void;
+    /**
+     * @param {WithStatement} statement with statement
+     */
+    walkWithStatement(statement: any): void;
+    /**
+     * @param {SwitchStatement} statement switch statement
+     */
+    preWalkSwitchStatement(statement: any): void;
+    /**
+     * @param {SwitchStatement} statement switch statement
+     */
+    walkSwitchStatement(statement: any): void;
+    /**
+     * @param {ReturnStatement | ThrowStatement} statement return or throw statement
+     */
+    walkTerminatingStatement(statement: any): void;
+    /**
+     * @param {ReturnStatement} statement return statement
+     */
+    walkReturnStatement(statement: any): void;
+    /**
+     * @param {ThrowStatement} statement return statement
+     */
+    walkThrowStatement(statement: any): void;
+    /**
+     * @param {TryStatement} statement try statement
+     */
+    preWalkTryStatement(statement: any): void;
+    /**
+     * @param {TryStatement} statement try statement
+     */
+    walkTryStatement(statement: any): void;
+    /**
+     * @param {WhileStatement} statement while statement
+     */
+    preWalkWhileStatement(statement: any): void;
+    /**
+     * @param {WhileStatement} statement while statement
+     */
+    walkWhileStatement(statement: any): void;
+    /**
+     * @param {DoWhileStatement} statement do while statement
+     */
+    preWalkDoWhileStatement(statement: any): void;
+    /**
+     * @param {DoWhileStatement} statement do while statement
+     */
+    walkDoWhileStatement(statement: any): void;
+    /**
+     * @param {ForStatement} statement for statement
+     */
+    preWalkForStatement(statement: any): void;
+    /**
+     * @param {ForStatement} statement for statement
+     */
+    walkForStatement(statement: any): void;
+    /**
+     * @param {ForInStatement} statement for statement
+     */
+    preWalkForInStatement(statement: any): void;
+    /**
+     * @param {ForInStatement} statement for statement
+     */
+    walkForInStatement(statement: any): void;
+    preWalkForOfStatement(statement: any): void;
+    /**
+     * @param {ForOfStatement} statement for statement
+     */
+    walkForOfStatement(statement: any): void;
+    /**
+     * @param {FunctionDeclaration} statement function declaration
+     */
+    preWalkFunctionDeclaration(statement: any): void;
+    /**
+     * @param {FunctionDeclaration} statement function declaration
+     */
+    walkFunctionDeclaration(statement: any): void;
+    /**
+     * @param {ExpressionStatement} statement expression statement
+     */
+    blockPreWalkExpressionStatement(statement: any): void;
+    /**
+     * @param {AssignmentExpression} expression assignment expression
+     */
+    preWalkAssignmentExpression(expression: any): void;
+    blockPreWalkImportDeclaration(statement: any): void;
+    enterDeclaration(declaration: any, onIdent: any): void;
+    blockPreWalkExportNamedDeclaration(statement: any): void;
+    /**
+     * @param {ExportNamedDeclaration} statement the statement
+     */
+    walkExportNamedDeclaration(statement: any): void;
+    blockPreWalkExportDefaultDeclaration(statement: any): void;
+    walkExportDefaultDeclaration(statement: any): void;
+    blockPreWalkExportAllDeclaration(statement: any): void;
+    /**
+     * @param {VariableDeclaration} statement variable declaration
+     */
+    preWalkVariableDeclaration(statement: any): void;
+    /**
+     * @param {VariableDeclaration} statement variable declaration
+     */
+    blockPreWalkVariableDeclaration(statement: any): void;
+    /**
+     * @param {VariableDeclaration} statement variable declaration
+     * @param {TODO} hookMap map of hooks
+     */
+    _preWalkVariableDeclaration(statement: any, hookMap: any): void;
+    /**
+     * @param {ObjectPattern} objectPattern object pattern
+     * @returns {Set<string> | undefined} set of names or undefined if not all keys are identifiers
+     */
+    _preWalkObjectPattern(objectPattern: any): Set<unknown> | undefined;
+    /**
+     * @param {VariableDeclarator} declarator variable declarator
+     */
+    preWalkVariableDeclarator(declarator: any): void;
+    /**
+     * @param {VariableDeclaration} statement variable declaration
+     */
+    walkVariableDeclaration(statement: any): void;
+    /**
+     * @param {ClassDeclaration} statement class declaration
+     */
+    blockPreWalkClassDeclaration(statement: any): void;
+    /**
+     * @param {ClassDeclaration} statement class declaration
+     */
+    walkClassDeclaration(statement: any): void;
+    /**
+     * @param {SwitchCase[]} switchCases switch statement
+     */
+    preWalkSwitchCases(switchCases: any): void;
+    /**
+     * @param {SwitchCase[]} switchCases switch statement
+     */
+    walkSwitchCases(switchCases: any): void;
+    /**
+     * @param {CatchClause} catchClause catch clause
+     */
+    preWalkCatchClause(catchClause: any): void;
+    /**
+     * @param {CatchClause} catchClause catch clause
+     */
+    walkCatchClause(catchClause: any): void;
+    /**
+     * @param {Pattern} pattern pattern
+     */
+    walkPattern(pattern: any): void;
+    /**
+     * @param {AssignmentPattern} pattern assignment pattern
+     */
+    walkAssignmentPattern(pattern: any): void;
+    walkObjectPattern(pattern: any): void;
+    /**
+     * @param {ArrayPattern} pattern array pattern
+     */
+    walkArrayPattern(pattern: any): void;
+    /**
+     * @param {RestElement} pattern rest element
+     */
+    walkRestElement(pattern: any): void;
+    /**
+     * @param {(Expression | SpreadElement | null)[]} expressions expressions
+     */
+    walkExpressions(expressions: any): void;
+    /**
+     * @param {TODO} expression expression
+     */
+    walkExpression(expression: any): void;
+    /**
+     * @param {AwaitExpression} expression await expression
+     */
+    walkAwaitExpression(expression: any): void;
+    /**
+     * @param {ArrayExpression} expression array expression
+     */
+    walkArrayExpression(expression: any): void;
+    /**
+     * @param {SpreadElement} expression spread element
+     */
+    walkSpreadElement(expression: any): void;
+    /**
+     * @param {ObjectExpression} expression object expression
+     */
+    walkObjectExpression(expression: any): void;
+    /**
+     * @param {Property | SpreadElement} prop property or spread element
+     */
+    walkProperty(prop: any): void;
+    /**
+     * @param {FunctionExpression} expression arrow function expression
+     */
+    walkFunctionExpression(expression: any): void;
+    /**
+     * @param {ArrowFunctionExpression} expression arrow function expression
+     */
+    walkArrowFunctionExpression(expression: any): void;
+    /**
+     * @param {SequenceExpression} expression the sequence
+     */
+    walkSequenceExpression(expression: any): void;
+    /**
+     * @param {UpdateExpression} expression the update expression
+     */
+    walkUpdateExpression(expression: any): void;
+    /**
+     * @param {UnaryExpression} expression the unary expression
+     */
+    walkUnaryExpression(expression: any): void;
+    /**
+     * @param {LogicalExpression | BinaryExpression} expression the expression
+     */
+    walkLeftRightExpression(expression: any): void;
+    /**
+     * @param {BinaryExpression} expression the binary expression
+     */
+    walkBinaryExpression(expression: any): void;
+    /**
+     * @param {LogicalExpression} expression the logical expression
+     */
+    walkLogicalExpression(expression: any): void;
+    /**
+     * @param {AssignmentExpression} expression assignment expression
+     */
+    walkAssignmentExpression(expression: any): void;
+    /**
+     * @param {ConditionalExpression} expression conditional expression
+     */
+    walkConditionalExpression(expression: any): void;
+    /**
+     * @param {NewExpression} expression new expression
+     */
+    walkNewExpression(expression: any): void;
+    /**
+     * @param {YieldExpression} expression yield expression
+     */
+    walkYieldExpression(expression: any): void;
+    /**
+     * @param {TemplateLiteral} expression template literal
+     */
+    walkTemplateLiteral(expression: any): void;
+    walkTaggedTemplateExpression(expression: any): void;
+    walkClassExpression(expression: any): void;
+    walkChainExpression(expression: any): void;
+    _walkIIFE(functionExpression: any, options: any, currentThis: any): void;
+    /**
+     * @param {ImportExpression} expression import expression
+     */
+    walkImportExpression(expression: any): void;
+    walkCallExpression(expression: any): void;
+    /**
+     * @param {MemberExpression} expression member expression
+     */
+    walkMemberExpression(expression: any): void;
+    walkMemberExpressionWithExpressionName(expression: any, name: any, rootInfo: any, members: any, onUnhandled: any): void;
+    /**
+     * @param {ThisExpression} expression this expression
+     */
+    walkThisExpression(expression: any): void;
+    /**
+     * @param {Identifier} expression identifier
+     */
+    walkIdentifier(expression: any): void;
+    /**
+     * @param {MetaProperty} metaProperty meta property
+     */
+    walkMetaProperty(metaProperty: any): void;
+    callHooksForExpression(hookMap: any, expr: any, ...args: any[]): any;
+    /**
+     * @template T
+     * @template R
+     * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+     * @param {MemberExpression} expr expression info
+     * @param {(function(string, string | ScopeInfo | VariableInfo, function(): string[]): any) | undefined} fallback callback when variable in not handled by hooks
+     * @param {(function(string): any) | undefined} defined callback when variable is defined
+     * @param {AsArray<T>} args args for the hook
+     * @returns {R | undefined} result of hook
+     */
+    callHooksForExpressionWithFallback(hookMap: any, expr: any, fallback: any, defined: any, ...args: any[]): any;
+    /**
+     * @template T
+     * @template R
+     * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+     * @param {string} name key in map
+     * @param {AsArray<T>} args args for the hook
+     * @returns {R | undefined} result of hook
+     */
+    callHooksForName(hookMap: any, name: any, ...args: any[]): any;
+    /**
+     * @template T
+     * @template R
+     * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks that should be called
+     * @param {ExportedVariableInfo} info variable info
+     * @param  {AsArray<T>} args args for the hook
+     * @returns {R | undefined} result of hook
+     */
+    callHooksForInfo(hookMap: any, info: any, ...args: any[]): any;
+    /**
+     * @template T
+     * @template R
+     * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+     * @param {ExportedVariableInfo} info variable info
+     * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+     * @param {(function(): any) | undefined} defined callback when variable is defined
+     * @param {AsArray<T>} args args for the hook
+     * @returns {R | undefined} result of hook
+     */
+    callHooksForInfoWithFallback(hookMap: any, info: any, fallback: any, defined: any, ...args: any[]): any;
+    /**
+     * @template T
+     * @template R
+     * @param {HookMap<SyncBailHook<T, R>>} hookMap hooks the should be called
+     * @param {string} name key in map
+     * @param {(function(string): any) | undefined} fallback callback when variable in not handled by hooks
+     * @param {(function(): any) | undefined} defined callback when variable is defined
+     * @param {AsArray<T>} args args for the hook
+     * @returns {R | undefined} result of hook
+     */
+    callHooksForNameWithFallback(hookMap: any, name: any, fallback: any, defined: any, ...args: any[]): any;
+    /**
+     * @deprecated
+     * @param {any} params scope params
+     * @param {function(): void} fn inner function
+     * @returns {void}
+     */
+    inScope(params: any, fn: any): void;
+    /**
+     * @param {boolean} hasThis true, when this is defined
+     * @param {any} params scope params
+     * @param {function(): void} fn inner function
+     * @returns {void}
+     */
+    inClassScope(hasThis: any, params: any, fn: any): void;
+    /**
+     * @param {boolean} hasThis true, when this is defined
+     * @param {any} params scope params
+     * @param {function(): void} fn inner function
+     * @returns {void}
+     */
+    inFunctionScope(hasThis: any, params: any, fn: any): void;
+    /**
+     * @param {function(): void} fn inner function
+     * @returns {void}
+     */
+    inBlockScope(fn: any): void;
+    /**
+     * @param {Array<Directive | Statement | ModuleDeclaration>} statements statements
+     */
+    detectMode(statements: any): void;
+    enterPatterns(patterns: any, onIdent: any): void;
+    enterPattern(pattern: any, onIdent: any): void;
+    /**
+     * @param {Identifier} pattern identifier pattern
+     * @param {TODO} onIdent callback
+     */
+    enterIdentifier(pattern: any, onIdent: any): void;
+    /**
+     * @param {ObjectPattern} pattern object pattern
+     * @param {TODO} onIdent callback
+     */
+    enterObjectPattern(pattern: any, onIdent: any): void;
+    /**
+     * @param {ArrayPattern} pattern object pattern
+     * @param {TODO} onIdent callback
+     */
+    enterArrayPattern(pattern: any, onIdent: any): void;
+    /**
+     * @param {RestElement} pattern object pattern
+     * @param {TODO} onIdent callback
+     */
+    enterRestElement(pattern: any, onIdent: any): void;
+    /**
+     * @param {AssignmentPattern} pattern object pattern
+     * @param {TODO} onIdent callback
+     */
+    enterAssignmentPattern(pattern: any, onIdent: any): void;
+    /**
+     * @param {TODO} expression expression node
+     * @returns {BasicEvaluatedExpression} evaluation result
+     */
+    evaluateExpression(expression: any): any;
+    /**
+     * @param {Expression} expression expression
+     * @returns {string} parsed string
+     */
+    parseString(expression: any): any;
+    parseCalculatedString(expression: any): any;
+    /**
+     * @param {string | Buffer | PreparsedAst} source the source to parse
+     * @param {ParserState} state the parser state
+     * @returns {ParserState} the parser state
+     */
+    parse(source: any, state: any): any;
+    /**
+     * @param {string} source source code
+     * @returns {BasicEvaluatedExpression} evaluation result
+     */
+    evaluate(source: any): any;
+    /**
+     * @param {Expression | Declaration | PrivateIdentifier | null | undefined} expr an expression
+     * @param {number} commentsStartPos source position from which annotation comments are checked
+     * @returns {boolean} true, when the expression is pure
+     */
+    isPure(expr: any, commentsStartPos: any): any;
+    getComments(range: any): any[];
+    isAsiPosition(pos: number): any;
+    /**
+     * @param {number} pos source code position
+     * @returns {void}
+     */
+    unsetAsiPosition(pos: any): void;
+    /**
+     * @param {Expression} expr expression
+     * @returns {boolean} true, when the expression is a statement level expression
+     */
+    isStatementLevelExpression(expr: any): boolean;
+    getTagData(name: any, tag: any): any;
+    tagVariable(name: any, tag: any, data: any): void;
+    defineVariable(name: string): void;
+    undefineVariable(name: any): void;
+    isVariableDefined(name: any): boolean;
+    getVariableInfo(name: any): any;
+    setVariable(name: any, variableInfo: any): void;
+    evaluatedVariable(tagInfo: any): VariableInfo;
+    parseCommentOptions(range: any): {
+        options: null;
+        errors: null;
+    } | {
+        options: {};
+        errors: any[];
+    };
+    extractMemberExpressionChain(expression: any): {
+        members: string[];
+        membersOptionals: any[];
+        memberRanges: any[];
+        object: any;
+    };
+    /**
+     * @param {string} varName variable name
+     * @returns {{name: string, info: VariableInfo | string} | undefined} name of the free variable and variable info for that
+     */
+    getFreeInfoFromVariable(varName: any): {
+        info: string | VariableInfo;
+        name: any;
+    } | undefined;
+    getMemberExpressionInfo(expression: any, allowedTypes: number): {
+        type: string;
+        call: any;
+        calleeName: any;
+        rootInfo: string | VariableInfo;
+        getCalleeMembers: any;
+        name: any;
+        getMembers: any;
+        getMembersOptionals: any;
+        getMemberRanges: any;
+    } | {
+        type: string;
+        name: any;
+        rootInfo: string | VariableInfo;
+        getMembers: any;
+        getMembersOptionals: any;
+        getMemberRanges: any;
+        call?: undefined;
+        calleeName?: undefined;
+        getCalleeMembers?: undefined;
+    } | undefined;
+    /**
+     * @param {MemberExpression} expression an expression
+     * @returns {{ name: string, rootInfo: ExportedVariableInfo, getMembers: () => string[]} | undefined} name info
+     */
+    getNameForExpression(expression: any): {
+        type: string;
+        call: any;
+        calleeName: any;
+        rootInfo: string | VariableInfo;
+        getCalleeMembers: any;
+        name: any;
+        getMembers: any;
+        getMembersOptionals: any;
+        getMemberRanges: any;
+    } | {
+        type: string;
+        name: any;
+        rootInfo: string | VariableInfo;
+        getMembers: any;
+        getMembersOptionals: any;
+        getMemberRanges: any;
+        call?: undefined;
+        calleeName?: undefined;
+        getCalleeMembers?: undefined;
+    } | undefined;
+    /**
+     * @param {string} code source code
+     * @param {ParseOptions} options parsing options
+     * @returns {Program} parsed ast
+     */
+    static _parse(code: any, options: any): any;
+}
+export { ALLOWED_MEMBER_TYPES_CALL_EXPRESSION, ALLOWED_MEMBER_TYPES_EXPRESSION, ALLOWED_MEMBER_TYPES_ALL, JavascriptParser, };