@sprucelabs/spruce-cli 17.1.36 → 17.1.39

package/node_modules/@typescript-eslint/typescript-estree/README.md

@@ -0,0 +1,383 @@
+<h1 align="center">TypeScript ESTree</h1>
+
+<p align="center">A parser that converts TypeScript source code into an <a href="https://github.com/estree/estree">ESTree</a>-compatible form</p>
+
+<p align="center">
+    <img src="https://github.com/typescript-eslint/typescript-eslint/workflows/CI/badge.svg" alt="CI" />
+    <a href="https://www.npmjs.com/package/@typescript-eslint/typescript-estree"><img src="https://img.shields.io/npm/v/@typescript-eslint/typescript-estree.svg?style=flat-square" alt="NPM Version" /></a>
+    <a href="https://www.npmjs.com/package/@typescript-eslint/typescript-estree"><img src="https://img.shields.io/npm/dm/@typescript-eslint/typescript-estree.svg?style=flat-square" alt="NPM Downloads" /></a>
+</p>
+
+## Getting Started
+
+**[You can find our Getting Started docs here](https://typescript-eslint.io/docs)**
+
+## About
+
+This parser is somewhat generic and robust, and could be used to power any use-case which requires taking TypeScript source code and producing an ESTree-compatible AST.
+
+In fact, it is already used within these hyper-popular open-source projects to power their TypeScript support:
+
+- [ESLint](https://eslint.org), the pluggable linting utility for JavaScript and JSX
+- [Prettier](https://prettier.io), an opinionated code formatter
+
+## Installation
+
+```sh
+yarn add -D @typescript-eslint/typescript-estree
+```
+
+## API
+
+### Parsing
+
+#### `parse(code, options)`
+
+Parses the given string of code with the options provided and returns an ESTree-compatible AST.
+
+```ts
+interface ParseOptions {
+  /**
+   * create a top-level comments array containing all comments
+   */
+  comment?: boolean;
+
+  /**
+   * An array of modules to turn explicit debugging on for.
+   * - 'typescript-eslint' is the same as setting the env var `DEBUG=typescript-eslint:*`
+   * - 'eslint' is the same as setting the env var `DEBUG=eslint:*`
+   * - 'typescript' is the same as setting `extendedDiagnostics: true` in your tsconfig compilerOptions
+   *
+   * For convenience, also supports a boolean:
+   * - true === ['typescript-eslint']
+   * - false === []
+   */
+  debugLevel?: boolean | ('typescript-eslint' | 'eslint' | 'typescript')[];
+
+  /**
+   * Cause the parser to error if it encounters an unknown AST node type (useful for testing).
+   * This case only usually occurs when TypeScript releases new features.
+   */
+  errorOnUnknownASTType?: boolean;
+
+  /**
+   * Absolute (or relative to `cwd`) path to the file being parsed.
+   */
+  filePath?: string;
+
+  /**
+   * Enable parsing of JSX.
+   * For more details, see https://www.typescriptlang.org/docs/handbook/jsx.html
+   *
+   * NOTE: this setting does not effect known file types (.js, .cjs, .mjs, .jsx, .ts, .mts, .cts, .tsx, .json) because the
+   * TypeScript compiler has its own internal handling for known file extensions.
+   *
+   * For the exact behavior, see https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/parser#parseroptionsecmafeaturesjsx
+   */
+  jsx?: boolean;
+
+  /**
+   * Controls whether the `loc` information to each node.
+   * The `loc` property is an object which contains the exact line/column the node starts/ends on.
+   * This is similar to the `range` property, except it is line/column relative.
+   */
+  loc?: boolean;
+
+  /*
+   * Allows overriding of function used for logging.
+   * When value is `false`, no logging will occur.
+   * When value is not provided, `console.log()` will be used.
+   */
+  loggerFn?: Function | false;
+
+  /**
+   * Controls whether the `range` property is included on AST nodes.
+   * The `range` property is a [number, number] which indicates the start/end index of the node in the file contents.
+   * This is similar to the `loc` property, except this is the absolute index.
+   */
+  range?: boolean;
+
+  /**
+   * Set to true to create a top-level array containing all tokens from the file.
+   */
+  tokens?: boolean;
+}
+
+const PARSE_DEFAULT_OPTIONS: ParseOptions = {
+  comment: false,
+  errorOnUnknownASTType: false,
+  filePath: 'estree.ts', // or 'estree.tsx', if you pass jsx: true
+  jsx: false,
+  loc: false,
+  loggerFn: undefined,
+  range: false,
+  tokens: false,
+};
+
+declare function parse(
+  code: string,
+  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
+): TSESTree.Program;
+```
+
+Example usage:
+
+```js
+import { parse } from '@typescript-eslint/typescript-estree';
+
+const code = `const hello: string = 'world';`;
+const ast = parse(code, {
+  loc: true,
+  range: true,
+});
+```
+
+#### `parseAndGenerateServices(code, options)`
+
+Parses the given string of code with the options provided and returns an ESTree-compatible AST. Accepts additional options which can be used to generate type information along with the AST.
+
+```ts
+interface ParseAndGenerateServicesOptions extends ParseOptions {
+  /**
+   * Causes the parser to error if the TypeScript compiler returns any unexpected syntax/semantic errors.
+   */
+  errorOnTypeScriptSyntacticAndSemanticIssues?: boolean;
+
+  /**
+   * ***EXPERIMENTAL FLAG*** - Use this at your own risk.
+   *
+   * Causes TS to use the source files for referenced projects instead of the compiled .d.ts files.
+   * This feature is not yet optimized, and is likely to cause OOMs for medium to large projects.
+   *
+   * This flag REQUIRES at least TS v3.9, otherwise it does nothing.
+   *
+   * See: https://github.com/typescript-eslint/typescript-eslint/issues/2094
+   */
+  EXPERIMENTAL_useSourceOfProjectReferenceRedirect?: boolean;
+
+  /**
+   * When `project` is provided, this controls the non-standard file extensions which will be parsed.
+   * It accepts an array of file extensions, each preceded by a `.`.
+   */
+  extraFileExtensions?: string[];
+
+  /**
+   * Absolute (or relative to `tsconfigRootDir`) path to the file being parsed.
+   * When `project` is provided, this is required, as it is used to fetch the file from the TypeScript compiler's cache.
+   */
+  filePath?: string;
+
+  /**
+   * Allows the user to control whether or not two-way AST node maps are preserved
+   * during the AST conversion process.
+   *
+   * By default: the AST node maps are NOT preserved, unless `project` has been specified,
+   * in which case the maps are made available on the returned `parserServices`.
+   *
+   * NOTE: If `preserveNodeMaps` is explicitly set by the user, it will be respected,
+   * regardless of whether or not `project` is in use.
+   */
+  preserveNodeMaps?: boolean;
+
+  /**
+   * Absolute (or relative to `tsconfigRootDir`) paths to the tsconfig(s).
+   * If this is provided, type information will be returned.
+   */
+  project?: string | string[];
+
+  /**
+   * If you provide a glob (or globs) to the project option, you can use this option to ignore certain folders from
+   * being matched by the globs.
+   * This accepts an array of globs to ignore.
+   *
+   * By default, this is set to ["/node_modules/"]
+   */
+  projectFolderIgnoreList?: string[];
+
+  /**
+   * The absolute path to the root directory for all provided `project`s.
+   */
+  tsconfigRootDir?: string;
+
+  /**
+   * An array of one or more instances of TypeScript Program objects to be used for type information.
+   * This overrides any program or programs that would have been computed from the `project` option.
+   * All linted files must be part of the provided program(s).
+   */
+  programs?: Program[];
+
+  /**
+   ***************************************************************************************
+   * IT IS RECOMMENDED THAT YOU DO NOT USE THIS OPTION, AS IT CAUSES PERFORMANCE ISSUES. *
+   ***************************************************************************************
+   *
+   * When passed with `project`, this allows the parser to create a catch-all, default program.
+   * This means that if the parser encounters a file not included in any of the provided `project`s,
+   * it will not error, but will instead parse the file and its dependencies in a new program.
+   */
+  createDefaultProgram?: boolean;
+
+  /**
+   * ESLint (and therefore typescript-eslint) is used in both "single run"/one-time contexts,
+   * such as an ESLint CLI invocation, and long-running sessions (such as continuous feedback
+   * on a file in an IDE).
+   *
+   * When typescript-eslint handles TypeScript Program management behind the scenes, this distinction
+   * is important because there is significant overhead to managing the so called Watch Programs
+   * needed for the long-running use-case.
+   *
+   * When allowAutomaticSingleRunInference is enabled, we will use common heuristics to infer
+   * whether or not ESLint is being used as part of a single run.
+   */
+  allowAutomaticSingleRunInference?: boolean;
+
+  /**
+   * Path to a file exporting a custom ModuleResolver.
+   */
+  moduleResolver?: string;
+}
+
+interface ParserServices {
+  program: ts.Program;
+  esTreeNodeToTSNodeMap: WeakMap<TSESTree.Node, ts.Node | ts.Token>;
+  tsNodeToESTreeNodeMap: WeakMap<ts.Node | ts.Token, TSESTree.Node>;
+  hasFullTypeInformation: boolean;
+}
+
+interface ParseAndGenerateServicesResult<T extends TSESTreeOptions> {
+  ast: TSESTree.Program;
+  services: ParserServices;
+}
+
+const PARSE_AND_GENERATE_SERVICES_DEFAULT_OPTIONS: ParseOptions = {
+  ...PARSE_DEFAULT_OPTIONS,
+  errorOnTypeScriptSyntacticAndSemanticIssues: false,
+  extraFileExtensions: [],
+  preserveNodeMaps: false, // or true, if you do not set this, but pass `project`
+  project: undefined,
+  projectFolderIgnoreList: ['/node_modules/'],
+  tsconfigRootDir: process.cwd(),
+};
+
+declare function parseAndGenerateServices(
+  code: string,
+  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
+): ParseAndGenerateServicesResult;
+```
+
+Example usage:
+
+```js
+import { parseAndGenerateServices } from '@typescript-eslint/typescript-estree';
+
+const code = `const hello: string = 'world';`;
+const { ast, services } = parseAndGenerateServices(code, {
+  filePath: '/some/path/to/file/foo.ts',
+  loc: true,
+  project: './tsconfig.json',
+  range: true,
+});
+```
+
+#### `parseWithNodeMaps(code, options)`
+
+Parses the given string of code with the options provided and returns both the ESTree-compatible AST as well as the node maps.
+This allows you to work with both ASTs without the overhead of types that may come with `parseAndGenerateServices`.
+
+```ts
+interface ParseWithNodeMapsResult<T extends TSESTreeOptions> {
+  ast: TSESTree.Program;
+  esTreeNodeToTSNodeMap: ParserServices['esTreeNodeToTSNodeMap'];
+  tsNodeToESTreeNodeMap: ParserServices['tsNodeToESTreeNodeMap'];
+}
+
+declare function parseWithNodeMaps(
+  code: string,
+  options: ParseOptions = PARSE_DEFAULT_OPTIONS,
+): ParseWithNodeMapsResult;
+```
+
+Example usage:
+
+```js
+import { parseWithNodeMaps } from '@typescript-eslint/typescript-estree';
+
+const code = `const hello: string = 'world';`;
+const { ast, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap } = parseWithNodeMaps(
+  code,
+  {
+    loc: true,
+    range: true,
+  },
+);
+```
+
+### `TSESTree`, `AST_NODE_TYPES` and `AST_TOKEN_TYPES`
+
+Types for the AST produced by the parse functions.
+
+- `TSESTree` is a namespace which contains object types representing all of the AST Nodes produced by the parser.
+- `AST_NODE_TYPES` is an enum which provides the values for every single AST node's `type` property.
+- `AST_TOKEN_TYPES` is an enum which provides the values for every single AST token's `type` property.
+
+### Utilities
+
+#### `createProgram(configFile, projectDirectory)`
+
+This serves as a utility method for users of the `ParseOptions.programs` feature to create a TypeScript program instance from a config file.
+
+```ts
+declare function createProgram(
+  configFile: string,
+  projectDirectory: string = process.cwd(),
+): import('typescript').Program;
+```
+
+Example usage:
+
+```js
+const tsESTree = require('@typescript-eslint/typescript-estree');
+
+const program = tsESTree.createProgram('tsconfig.json');
+const code = `const hello: string = 'world';`;
+const { ast, services } = parseAndGenerateServices(code, {
+  filePath: '/some/path/to/file/foo.ts',
+  loc: true,
+  program,
+  range: true,
+});
+```
+
+## Supported TypeScript Version
+
+See the [Supported TypeScript Version](../../README.md#supported-typescript-version) section in the project root.
+
+If you use a non-supported version of TypeScript, the parser will log a warning to the console.
+
+**Please ensure that you are using a supported version before submitting any issues/bug reports.**
+
+## Reporting Issues
+
+Please check the current list of open and known issues and ensure the issue has not been reported before. When creating a new issue provide as much information about your environment as possible. This includes:
+
+- TypeScript version
+- The `typescript-estree` version
+
+## AST Alignment Tests
+
+A couple of years after work on this parser began, the TypeScript Team at Microsoft began [officially supporting TypeScript parsing via Babel](https://blogs.msdn.microsoft.com/typescript/2018/08/27/typescript-and-babel-7/).
+
+I work closely with the TypeScript Team and we are gradually aligning the AST of this project with the one produced by Babel's parser. To that end, I have created a full test harness to compare the ASTs of the two projects which runs on every PR, please see [the code](https://github.com/typescript-eslint/typescript-eslint/tree/main/packages/typescript-estree/tests/ast-alignment) for more details.
+
+## Debugging
+
+If you encounter a bug with the parser that you want to investigate, you can turn on the debug logging via setting the environment variable: `DEBUG=typescript-eslint:*`.
+I.e. in this repo you can run: `DEBUG=typescript-eslint:* yarn lint`.
+
+## License
+
+TypeScript ESTree inherits from the the original TypeScript ESLint Parser license, as the majority of the work began there. It is licensed under a permissive BSD 2-clause license.
+
+## Contributing
+
+[See the contributing guide here](../../CONTRIBUTING.md)

package/node_modules/@typescript-eslint/typescript-estree/dist/ast-converter.d.ts

@@ -0,0 +1,9 @@
+import type { SourceFile } from 'typescript';
+import { ASTMaps } from './convert';
+import type { Extra } from './parser-options';
+import type { TSESTree } from './ts-estree';
+export declare function astConverter(ast: SourceFile, extra: Extra, shouldPreserveNodeMaps: boolean): {
+    estree: TSESTree.Program;
+    astMaps: ASTMaps;
+};
+//# sourceMappingURL=ast-converter.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/dist/ast-converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-converter.d.ts","sourceRoot":"","sources":["../src/ast-converter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,EAA2B,OAAO,EAAE,MAAM,WAAW,CAAC;AAG7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,wBAAgB,YAAY,CAC1B,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,KAAK,EACZ,sBAAsB,EAAE,OAAO,GAC9B;IAAE,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAyDhD"}

package/node_modules/@typescript-eslint/typescript-estree/dist/ast-converter.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astConverter = void 0;
+const convert_1 = require("./convert");
+const convert_comments_1 = require("./convert-comments");
+const node_utils_1 = require("./node-utils");
+const simple_traverse_1 = require("./simple-traverse");
+function astConverter(ast, extra, shouldPreserveNodeMaps) {
+    /**
+     * The TypeScript compiler produced fundamental parse errors when parsing the
+     * source.
+     */
+    const { parseDiagnostics } = ast;
+    if (parseDiagnostics.length) {
+        throw (0, convert_1.convertError)(parseDiagnostics[0]);
+    }
+    /**
+     * Recursively convert the TypeScript AST into an ESTree-compatible AST
+     */
+    const instance = new convert_1.Converter(ast, {
+        errorOnUnknownASTType: extra.errorOnUnknownASTType || false,
+        shouldPreserveNodeMaps,
+    });
+    const estree = instance.convertProgram();
+    /**
+     * Optionally remove range and loc if specified
+     */
+    if (!extra.range || !extra.loc) {
+        (0, simple_traverse_1.simpleTraverse)(estree, {
+            enter: node => {
+                if (!extra.range) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- TS 4.0 made this an error because the types aren't optional
+                    // @ts-expect-error
+                    delete node.range;
+                }
+                if (!extra.loc) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment -- TS 4.0 made this an error because the types aren't optional
+                    // @ts-expect-error
+                    delete node.loc;
+                }
+            },
+        });
+    }
+    /**
+     * Optionally convert and include all tokens in the AST
+     */
+    if (extra.tokens) {
+        estree.tokens = (0, node_utils_1.convertTokens)(ast);
+    }
+    /**
+     * Optionally convert and include all comments in the AST
+     */
+    if (extra.comment) {
+        estree.comments = (0, convert_comments_1.convertComments)(ast, extra.code);
+    }
+    const astMaps = instance.getASTMaps();
+    return { estree, astMaps };
+}
+exports.astConverter = astConverter;
+//# sourceMappingURL=ast-converter.js.map

package/node_modules/@typescript-eslint/typescript-estree/dist/ast-converter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-converter.js","sourceRoot":"","sources":["../src/ast-converter.ts"],"names":[],"mappings":";;;AACA,uCAA6D;AAC7D,yDAAqD;AACrD,6CAA6C;AAG7C,uDAAmD;AAEnD,SAAgB,YAAY,CAC1B,GAAe,EACf,KAAY,EACZ,sBAA+B;IAE/B;;;OAGG;IACH,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAG,CAAC;IACjC,IAAI,gBAAgB,CAAC,MAAM,EAAE;QAC3B,MAAM,IAAA,sBAAY,EAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC;KACzC;IAED;;OAEG;IACH,MAAM,QAAQ,GAAG,IAAI,mBAAS,CAAC,GAAG,EAAE;QAClC,qBAAqB,EAAE,KAAK,CAAC,qBAAqB,IAAI,KAAK;QAC3D,sBAAsB;KACvB,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,QAAQ,CAAC,cAAc,EAAE,CAAC;IAEzC;;OAEG;IACH,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE;QAC9B,IAAA,gCAAc,EAAC,MAAM,EAAE;YACrB,KAAK,EAAE,IAAI,CAAC,EAAE;gBACZ,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE;oBAChB,4HAA4H;oBAC5H,mBAAmB;oBACnB,OAAO,IAAI,CAAC,KAAK,CAAC;iBACnB;gBACD,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE;oBACd,4HAA4H;oBAC5H,mBAAmB;oBACnB,OAAO,IAAI,CAAC,GAAG,CAAC;iBACjB;YACH,CAAC;SACF,CAAC,CAAC;KACJ;IAED;;OAEG;IACH,IAAI,KAAK,CAAC,MAAM,EAAE;QAChB,MAAM,CAAC,MAAM,GAAG,IAAA,0BAAa,EAAC,GAAG,CAAC,CAAC;KACpC;IAED;;OAEG;IACH,IAAI,KAAK,CAAC,OAAO,EAAE;QACjB,MAAM,CAAC,QAAQ,GAAG,IAAA,kCAAe,EAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;KACpD;IAED,MAAM,OAAO,GAAG,QAAQ,CAAC,UAAU,EAAE,CAAC;IAEtC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;AAC7B,CAAC;AA7DD,oCA6DC"}

package/node_modules/@typescript-eslint/typescript-estree/dist/convert-comments.d.ts

@@ -0,0 +1,11 @@
+import * as ts from 'typescript';
+import { TSESTree } from './ts-estree';
+/**
+ * Convert all comments for the given AST.
+ * @param ast the AST object
+ * @param code the TypeScript code
+ * @returns the converted ESTreeComment
+ * @private
+ */
+export declare function convertComments(ast: ts.SourceFile, code: string): TSESTree.Comment[];
+//# sourceMappingURL=convert-comments.d.ts.map

package/node_modules/@typescript-eslint/typescript-estree/dist/convert-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-comments.d.ts","sourceRoot":"","sources":["../src/convert-comments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAGjC,OAAO,EAAmB,QAAQ,EAAE,MAAM,aAAa,CAAC;AAExD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,EAAE,CAAC,UAAU,EAClB,IAAI,EAAE,MAAM,GACX,QAAQ,CAAC,OAAO,EAAE,CAgCpB"}

package/node_modules/@typescript-eslint/typescript-estree/dist/convert-comments.js

@@ -0,0 +1,63 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertComments = void 0;
+const ts = __importStar(require("typescript"));
+const util_1 = require("tsutils/util/util");
+const node_utils_1 = require("./node-utils");
+const ts_estree_1 = require("./ts-estree");
+/**
+ * Convert all comments for the given AST.
+ * @param ast the AST object
+ * @param code the TypeScript code
+ * @returns the converted ESTreeComment
+ * @private
+ */
+function convertComments(ast, code) {
+    const comments = [];
+    (0, util_1.forEachComment)(ast, (_, comment) => {
+        const type = comment.kind == ts.SyntaxKind.SingleLineCommentTrivia
+            ? ts_estree_1.AST_TOKEN_TYPES.Line
+            : ts_estree_1.AST_TOKEN_TYPES.Block;
+        const range = [comment.pos, comment.end];
+        const loc = (0, node_utils_1.getLocFor)(range[0], range[1], ast);
+        // both comments start with 2 characters - /* or //
+        const textStart = range[0] + 2;
+        const textEnd = comment.kind === ts.SyntaxKind.SingleLineCommentTrivia
+            ? // single line comments end at the end
+                range[1] - textStart
+            : // multiline comments end 2 characters early
+                range[1] - textStart - 2;
+        comments.push({
+            type,
+            value: code.slice(textStart, textStart + textEnd),
+            range,
+            loc,
+        });
+    }, ast);
+    return comments;
+}
+exports.convertComments = convertComments;
+//# sourceMappingURL=convert-comments.js.map

package/node_modules/@typescript-eslint/typescript-estree/dist/convert-comments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-comments.js","sourceRoot":"","sources":["../src/convert-comments.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,4CAAmD;AACnD,6CAAyC;AACzC,2CAAwD;AAExD;;;;;;GAMG;AACH,SAAgB,eAAe,CAC7B,GAAkB,EAClB,IAAY;IAEZ,MAAM,QAAQ,GAAuB,EAAE,CAAC;IAExC,IAAA,qBAAc,EACZ,GAAG,EACH,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE;QACb,MAAM,IAAI,GACR,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACnD,CAAC,CAAC,2BAAe,CAAC,IAAI;YACtB,CAAC,CAAC,2BAAe,CAAC,KAAK,CAAC;QAC5B,MAAM,KAAK,GAAmB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,IAAA,sBAAS,EAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAE/C,mDAAmD;QACnD,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/B,MAAM,OAAO,GACX,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC,UAAU,CAAC,uBAAuB;YACpD,CAAC,CAAC,sCAAsC;gBACtC,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS;YACtB,CAAC,CAAC,4CAA4C;gBAC5C,KAAK,CAAC,CAAC,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;QAC/B,QAAQ,CAAC,IAAI,CAAC;YACZ,IAAI;YACJ,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC;YACjD,KAAK;YACL,GAAG;SACJ,CAAC,CAAC;IACL,CAAC,EACD,GAAG,CACJ,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC;AAnCD,0CAmCC"}