Blame view

node_modules/@babel/parser/typings/babel-parser.d.ts 3.22 KB
ce4c83ff   wxy   初始提交
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
  // Type definitions for @babel/parser
  // Project: https://github.com/babel/babel/tree/master/packages/babel-parser
  // Definitions by: Troy Gerwien <https://github.com/yortus>
  //                 Marvin Hagemeister <https://github.com/marvinhagemeister>
  //                 Avi Vahl <https://github.com/AviVahl>
  // TypeScript Version: 2.9
  
  /**
   * Parse the provided code as an entire ECMAScript program.
   */
  export function parse(input: string, options?: ParserOptions): import('@babel/types').File;
  
  /**
   * Parse the provided code as a single expression.
   */
  export function parseExpression(input: string, options?: ParserOptions): import('@babel/types').Expression;
  
  export interface ParserOptions {
      /**
       * By default, import and export declarations can only appear at a program's top level.
       * Setting this option to true allows them anywhere where a statement is allowed.
       */
      allowImportExportEverywhere?: boolean;
  
      /**
       * By default, await use is not allowed outside of an async function.
       * Set this to true to accept such code.
       */
      allowAwaitOutsideFunction?: boolean;
  
      /**
       * By default, a return statement at the top level raises an error.
       * Set this to true to accept such code.
       */
      allowReturnOutsideFunction?: boolean;
  
      allowSuperOutsideMethod?: boolean;
  
      /**
       * Indicate the mode the code should be parsed in.
       * Can be one of "script", "module", or "unambiguous". Defaults to "script".
       * "unambiguous" will make @babel/parser attempt to guess, based on the presence
       * of ES6 import or export statements.
       * Files with ES6 imports and exports are considered "module" and are otherwise "script".
       */
      sourceType?: 'script' | 'module' | 'unambiguous';
  
      /**
       * Correlate output AST nodes with their source filename.
       * Useful when generating code and source maps from the ASTs of multiple input files.
       */
      sourceFilename?: string;
  
      /**
       * By default, the first line of code parsed is treated as line 1.
       * You can provide a line number to alternatively start with.
       * Useful for integration with other source tools.
       */
      startLine?: number;
  
      /**
       * Array containing the plugins that you want to enable.
       */
      plugins?: ParserPlugin[];
  
      /**
       * Should the parser work in strict mode.
       * Defaults to true if sourceType === 'module'. Otherwise, false.
       */
      strictMode?: boolean;
  
      /**
       * Adds a ranges property to each node: [node.start, node.end]
       */
      ranges?: boolean;
  
      /**
       * Adds all parsed tokens to a tokens property on the File node.
       */
      tokens?: boolean;
  }
  
  export type ParserPlugin =
      'estree' |
      'jsx' |
      'flow' |
      'flowComments' |
      'typescript' |
      'doExpressions' |
      'objectRestSpread' |
      'decorators' |
      'decorators-legacy' |
      'classProperties' |
      'classPrivateProperties' |
      'classPrivateMethods' |
      'exportDefaultFrom' |
      'exportNamespaceFrom' |
      'asyncGenerators' |
      'functionBind' |
      'functionSent' |
      'dynamicImport' |
      'numericSeparator' |
      'optionalChaining' |
      'importMeta' |
      'bigInt' |
      'optionalCatchBinding' |
      'throwExpressions' |
      'pipelineOperator' |
      'nullishCoalescingOperator';