@zzzen/pyright-internal 1.1.254

package/dist/tests/fourslash/signature.docstrings.wildcardimports.fourslash.js

@@ -0,0 +1,115 @@
+"use strict";
+/// <reference path="fourslash.ts" />
+// @filename: lib1/definition.py
+// @library: true
+//// def func():
+////     '''func docs'''
+////     pass
+////
+//// class MyType:
+////     def func2():
+////         '''func2 docs'''
+////         pass
+// @filename: lib1/alias.py
+// @library: true
+//// def func3():
+////     '''func3 docs'''
+////     pass
+// @filename: lib1/withall.py
+// @library: true
+//// def func4():
+////     '''func4 docs'''
+////     pass
+////
+//// def func5():
+////     '''func5 docs'''
+////     pass
+////
+//// __all__ = ['func5']
+// @filename: lib1/redirect.py
+// @library: true
+//// from . import withall
+//// from .withall import *
+////
+//// __all__ += withall.__all__
+// @filename: lib1/wildcard.py
+// @library: true
+//// from .definition import *
+//// from .redirect import *
+//// from .alias import func3
+// @filename: lib1/__init__.py
+// @library: true
+//// from .wildcard import *
+// @filename: lib1/__init__.pyi
+// @library: true
+//// class ufunc:
+////     def __call__(self) -> None : ...
+////
+//// func: ufunc
+//// class MyType:
+////     def func2() -> None : ...
+//// func3: ufunc
+//// func4: ufunc
+//// func5: ufunc
+// @filename: test.py
+//// import lib1
+//// lib1.func([|/*marker1*/|])
+//// lib1.MyType().func2([|/*marker2*/|])
+//// lib1.func3([|/*marker3*/|])
+//// lib1.func4([|/*marker4*/|])
+//// lib1.func5([|/*marker5*/|])
+{
+    helper.verifySignature('markdown', {
+        marker1: {
+            signatures: [
+                {
+                    label: '() -> None',
+                    parameters: [],
+                    documentation: 'func docs',
+                },
+            ],
+            activeParameters: [undefined],
+        },
+        marker2: {
+            signatures: [
+                {
+                    label: '() -> None',
+                    parameters: [],
+                    documentation: 'func2 docs',
+                },
+            ],
+            activeParameters: [undefined],
+        },
+        marker3: {
+            signatures: [
+                {
+                    label: '() -> None',
+                    parameters: [],
+                    documentation: 'func3 docs',
+                },
+            ],
+            activeParameters: [undefined],
+        },
+        marker4: {
+            signatures: [
+                {
+                    label: '() -> None',
+                    parameters: [],
+                    documentation: 'func4 docs',
+                },
+            ],
+            activeParameters: [undefined],
+        },
+        marker5: {
+            signatures: [
+                {
+                    label: '() -> None',
+                    parameters: [],
+                    documentation: 'func5 docs',
+                },
+            ],
+            activeParameters: [undefined],
+        },
+    });
+}
+//# sourceMappingURL=signature.docstrings.wildcardimports.fourslash.js.map

package/dist/tests/fourslash/signature.docstrings.wildcardimports.fourslash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.docstrings.wildcardimports.fourslash.js","sourceRoot":"","sources":["../../../../src/tests/fourslash/signature.docstrings.wildcardimports.fourslash.ts"],"names":[],"mappings":";AAAA,qCAAqC;AAErC,gCAAgC;AAChC,iBAAiB;AACjB,gBAAgB;AAChB,wBAAwB;AACxB,aAAa;AACb,IAAI;AACJ,kBAAkB;AAClB,qBAAqB;AACrB,6BAA6B;AAC7B,iBAAiB;AAEjB,2BAA2B;AAC3B,iBAAiB;AACjB,iBAAiB;AACjB,yBAAyB;AACzB,aAAa;AAEb,6BAA6B;AAC7B,iBAAiB;AACjB,iBAAiB;AACjB,yBAAyB;AACzB,aAAa;AACb,IAAI;AACJ,iBAAiB;AACjB,yBAAyB;AACzB,aAAa;AACb,IAAI;AACJ,wBAAwB;AAExB,8BAA8B;AAC9B,iBAAiB;AACjB,0BAA0B;AAC1B,2BAA2B;AAC3B,IAAI;AACJ,+BAA+B;AAE/B,8BAA8B;AAC9B,iBAAiB;AACjB,8BAA8B;AAC9B,4BAA4B;AAC5B,6BAA6B;AAE7B,8BAA8B;AAC9B,iBAAiB;AACjB,4BAA4B;AAE5B,+BAA+B;AAC/B,iBAAiB;AACjB,iBAAiB;AACjB,yCAAyC;AACzC,IAAI;AACJ,gBAAgB;AAChB,kBAAkB;AAClB,kCAAkC;AAClC,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AAEjB,qBAAqB;AACrB,gBAAgB;AAChB,+BAA+B;AAC/B,yCAAyC;AACzC,gCAAgC;AAChC,gCAAgC;AAChC,gCAAgC;AAEhC;IACI,MAAM,CAAC,eAAe,CAAC,UAAU,EAAE;QAC/B,OAAO,EAAE;YACL,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,YAAY;oBACnB,UAAU,EAAE,EAAE;oBACd,aAAa,EAAE,WAAW;iBAC7B;aACJ;YACD,gBAAgB,EAAE,CAAC,SAAS,CAAC;SAChC;QACD,OAAO,EAAE;YACL,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,YAAY;oBACnB,UAAU,EAAE,EAAE;oBACd,aAAa,EAAE,YAAY;iBAC9B;aACJ;YACD,gBAAgB,EAAE,CAAC,SAAS,CAAC;SAChC;QACD,OAAO,EAAE;YACL,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,YAAY;oBACnB,UAAU,EAAE,EAAE;oBACd,aAAa,EAAE,YAAY;iBAC9B;aACJ;YACD,gBAAgB,EAAE,CAAC,SAAS,CAAC;SAChC;QACD,OAAO,EAAE;YACL,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,YAAY;oBACnB,UAAU,EAAE,EAAE;oBACd,aAAa,EAAE,YAAY;iBAC9B;aACJ;YACD,gBAAgB,EAAE,CAAC,SAAS,CAAC;SAChC;QACD,OAAO,EAAE;YACL,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,YAAY;oBACnB,UAAU,EAAE,EAAE;oBACd,aAAa,EAAE,YAAY;iBAC9B;aACJ;YACD,gBAAgB,EAAE,CAAC,SAAS,CAAC;SAChC;KACJ,CAAC,CAAC;CACN"}

package/dist/tests/fourslash/signature.overload.fourslash.d.ts

@@ -0,0 +1 @@
+/// <reference path="fourslash.d.ts" />

package/dist/tests/fourslash/signature.overload.fourslash.js

@@ -0,0 +1,63 @@
+"use strict";
+/// <reference path="fourslash.ts" />
+// @filename: overloaded.py
+//// from typing import overload
+////
+//// @overload
+//// def foo() -> int: ...
+////
+//// @overload
+//// def foo(x: int) -> int: ...
+////
+//// @overload
+//// def foo(x: int, y: int) -> str: ...
+////
+//// def foo(*args): ...
+////
+//// foo(1[|/*o1*/|], 2[|/*o2*/|])
+////
+//// foo(1, 2, [|/*o3*/|])
+////
+//// foo(1, 2, someVar[|/*o4*/|]   , 4, 5, 6, 7, 8)
+////
+//// foo([|/*o5*/|])
+{
+    const overloadedSignatures = [
+        {
+            label: '() -> int',
+            parameters: [],
+        },
+        {
+            label: '(x: int) -> int',
+            parameters: ['x: int'],
+        },
+        {
+            label: '(x: int, y: int) -> str',
+            parameters: ['x: int', 'y: int'],
+        },
+    ];
+    helper.verifySignature('plaintext', {
+        o1: {
+            signatures: overloadedSignatures,
+            activeParameters: [undefined, 0, 0],
+        },
+        o2: {
+            signatures: overloadedSignatures,
+            activeParameters: [undefined, undefined, 1],
+        },
+        o3: {
+            signatures: overloadedSignatures,
+            activeParameters: [undefined, undefined, undefined],
+        },
+        o4: {
+            signatures: overloadedSignatures,
+            activeParameters: [undefined, undefined, undefined],
+        },
+        o5: {
+            signatures: overloadedSignatures,
+            activeParameters: [undefined, 0, 0],
+            callHasParameters: false,
+        },
+    });
+}
+//# sourceMappingURL=signature.overload.fourslash.js.map

package/dist/tests/fourslash/signature.overload.fourslash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.overload.fourslash.js","sourceRoot":"","sources":["../../../../src/tests/fourslash/signature.overload.fourslash.ts"],"names":[],"mappings":";AAAA,qCAAqC;AAErC,2BAA2B;AAC3B,gCAAgC;AAChC,IAAI;AACJ,cAAc;AACd,0BAA0B;AAC1B,IAAI;AACJ,cAAc;AACd,gCAAgC;AAChC,IAAI;AACJ,cAAc;AACd,wCAAwC;AACxC,IAAI;AACJ,wBAAwB;AACxB,IAAI;AACJ,kCAAkC;AAClC,IAAI;AACJ,0BAA0B;AAC1B,IAAI;AACJ,mDAAmD;AACnD,IAAI;AACJ,oBAAoB;AAEpB;IACI,MAAM,oBAAoB,GAAG;QACzB;YACI,KAAK,EAAE,WAAW;YAClB,UAAU,EAAE,EAAE;SACjB;QACD;YACI,KAAK,EAAE,iBAAiB;YACxB,UAAU,EAAE,CAAC,QAAQ,CAAC;SACzB;QACD;YACI,KAAK,EAAE,yBAAyB;YAChC,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;SACnC;KACJ,CAAC;IAEF,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE;QAChC,EAAE,EAAE;YACA,UAAU,EAAE,oBAAoB;YAChC,gBAAgB,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;SACtC;QACD,EAAE,EAAE;YACA,UAAU,EAAE,oBAAoB;YAChC,gBAAgB,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,CAAC;SAC9C;QACD,EAAE,EAAE;YACA,UAAU,EAAE,oBAAoB;YAChC,gBAAgB,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC;SACtD;QACD,EAAE,EAAE;YACA,UAAU,EAAE,oBAAoB;YAChC,gBAAgB,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC;SACtD;QACD,EAAE,EAAE;YACA,UAAU,EAAE,oBAAoB;YAChC,gBAAgB,EAAE,CAAC,SAAS,EAAE,CAAC,EAAE,CAAC,CAAC;YACnC,iBAAiB,EAAE,KAAK;SAC3B;KACJ,CAAC,CAAC;CACN"}

package/dist/tests/fourslash/signature.simple.fourslash.d.ts

@@ -0,0 +1 @@
+/// <reference path="fourslash.d.ts" />

package/dist/tests/fourslash/signature.simple.fourslash.js

@@ -0,0 +1,104 @@
+"use strict";
+/// <reference path="fourslash.ts" />
+// @filename: simple.py
+////
+//// def simple(x: int, y: int) -> int: ...
+////
+//// simple([|/*s1*/|])[|/*sOutside*/|]
+////
+//// simple(1, [|/*s2*/|])
+////
+//// simple( [|/*s3*/|]   1  [|/*s4*/|]  , [|/*s5*/|] 2     [|/*s6*/|]
+////   [|/*s7*/|]  )
+////
+//// x = 1234[|/*sNoCall*/|]
+////
+//// 'string([|/*sNoCallInString*/|]'.capitalize()
+////
+//// f'format string([|/*sNoCallInFormatString*/|]'.capitalize()
+////
+//// f'format string {int.as_integer_ratio([|/*s8*/|])} '.capitalize()
+////
+//// def foo(f:str): ...
+////
+//// def bar(b:str): ...
+////
+//// bar([|/*nestedString1*/|]foo([|/*nestedString2*/|]))
+{
+    const simpleSignatures = [
+        {
+            label: '(x: int, y: int) -> int',
+            parameters: ['x: int', 'y: int'],
+        },
+    ];
+    helper.verifySignature('plaintext', {
+        s1: {
+            signatures: simpleSignatures,
+            activeParameters: [0],
+        },
+        s2: {
+            signatures: simpleSignatures,
+            activeParameters: [1],
+        },
+        s3: {
+            signatures: simpleSignatures,
+            activeParameters: [0],
+        },
+        s4: {
+            signatures: simpleSignatures,
+            activeParameters: [0],
+        },
+        s5: {
+            signatures: simpleSignatures,
+            activeParameters: [1],
+        },
+        s6: {
+            signatures: simpleSignatures,
+            activeParameters: [1],
+        },
+        s7: {
+            signatures: simpleSignatures,
+            activeParameters: [1],
+        },
+        sOutside: {
+            noSig: true,
+        },
+        sNoCall: {
+            noSig: true,
+        },
+        sNoCallInString: {
+            noSig: true,
+        },
+        sNoCallInFormatString: {
+            noSig: true,
+        },
+        s8: {
+            signatures: [
+                {
+                    label: '(self: int) -> tuple[int, Literal[1]]',
+                    parameters: ['self: int'],
+                },
+            ],
+            activeParameters: [0],
+        },
+        nestedString1: {
+            signatures: [
+                {
+                    label: '(b: str) -> None',
+                    parameters: ['b: str'],
+                },
+            ],
+            activeParameters: [0],
+        },
+        nestedString2: {
+            signatures: [
+                {
+                    label: '(f: str) -> None',
+                    parameters: ['f: str'],
+                },
+            ],
+            activeParameters: [0],
+        },
+    });
+}
+//# sourceMappingURL=signature.simple.fourslash.js.map

package/dist/tests/fourslash/signature.simple.fourslash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.simple.fourslash.js","sourceRoot":"","sources":["../../../../src/tests/fourslash/signature.simple.fourslash.ts"],"names":[],"mappings":";AAAA,qCAAqC;AAErC,uBAAuB;AACvB,IAAI;AACJ,2CAA2C;AAC3C,IAAI;AACJ,uCAAuC;AACvC,IAAI;AACJ,0BAA0B;AAC1B,IAAI;AACJ,sEAAsE;AACtE,oBAAoB;AACpB,IAAI;AACJ,4BAA4B;AAC5B,IAAI;AACJ,kDAAkD;AAClD,IAAI;AACJ,gEAAgE;AAChE,IAAI;AACJ,sEAAsE;AACtE,IAAI;AACJ,wBAAwB;AACxB,IAAI;AACJ,wBAAwB;AACxB,IAAI;AACJ,yDAAyD;AACzD;IACI,MAAM,gBAAgB,GAAG;QACrB;YACI,KAAK,EAAE,yBAAyB;YAChC,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC;SACnC;KACJ,CAAC;IAEF,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE;QAChC,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,EAAE,EAAE;YACA,UAAU,EAAE,gBAAgB;YAC5B,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,QAAQ,EAAE;YACN,KAAK,EAAE,IAAI;SACd;QACD,OAAO,EAAE;YACL,KAAK,EAAE,IAAI;SACd;QACD,eAAe,EAAE;YACb,KAAK,EAAE,IAAI;SACd;QACD,qBAAqB,EAAE;YACnB,KAAK,EAAE,IAAI;SACd;QACD,EAAE,EAAE;YACA,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,uCAAuC;oBAC9C,UAAU,EAAE,CAAC,WAAW,CAAC;iBAC5B;aACJ;YACD,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,aAAa,EAAE;YACX,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,kBAAkB;oBACzB,UAAU,EAAE,CAAC,QAAQ,CAAC;iBACzB;aACJ;YACD,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;QACD,aAAa,EAAE;YACX,UAAU,EAAE;gBACR;oBACI,KAAK,EAAE,kBAAkB;oBACzB,UAAU,EAAE,CAAC,QAAQ,CAAC;iBACzB;aACJ;YACD,gBAAgB,EAAE,CAAC,CAAC,CAAC;SACxB;KACJ,CAAC,CAAC;CACN"}

package/dist/tests/harness/fourslash/fourSlashParser.d.ts

@@ -0,0 +1,10 @@
+import { FourSlashData } from './fourSlashTypes';
+/**
+ * Parse given fourslash markup code and return content with markup/range data
+ *
+ * @param basePath this will be combined with given `fileName` to form filepath to this content
+ * @param contents content with fourslash markups.
+ * @param fileName this will be a default filename for the first no named content in `contents`.
+ *                 if content is marked with `@filename`, that will override this given `filename`
+ */
+export declare function parseTestData(basePath: string, contents: string, fileName: string): FourSlashData;

package/dist/tests/harness/fourslash/fourSlashParser.js

@@ -0,0 +1,347 @@
+"use strict";
+/*
+ * fourSlashParser.ts
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT license.
+ *
+ * Parse fourslash markup code and return parsed content with marker/range data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTestData = void 0;
+const collectionUtils_1 = require("../../../common/collectionUtils");
+const core_1 = require("../../../common/core");
+const pathUtils_1 = require("../../../common/pathUtils");
+const factory_1 = require("../vfs/factory");
+const fourSlashTypes_1 = require("./fourSlashTypes");
+/**
+ * Parse given fourslash markup code and return content with markup/range data
+ *
+ * @param basePath this will be combined with given `fileName` to form filepath to this content
+ * @param contents content with fourslash markups.
+ * @param fileName this will be a default filename for the first no named content in `contents`.
+ *                 if content is marked with `@filename`, that will override this given `filename`
+ */
+function parseTestData(basePath, contents, fileName) {
+    const normalizedBasePath = (0, pathUtils_1.normalizeSlashes)(basePath);
+    // Regex for parsing options in the format "@Alpha: Value of any sort"
+    const optionRegex = /^\s*@(\w+):\s*(.*)\s*/;
+    // List of all the subfiles we've parsed out
+    const files = [];
+    // Global options
+    const globalOptions = {};
+    // Marker positions
+    // Split up the input file by line
+    // Note: IE JS engine incorrectly handles consecutive delimiters here when using RegExp split, so
+    // we have to string-based splitting instead and try to figure out the delimiting chars
+    const lines = contents.split('\n');
+    let i = 0;
+    const markerPositions = new Map();
+    const markers = [];
+    const ranges = [];
+    // Stuff related to the subfile we're parsing
+    let currentFileContent;
+    let currentFileName = (0, pathUtils_1.normalizeSlashes)(fileName);
+    let currentFileOptions = {};
+    function nextFile() {
+        if (currentFileContent === undefined) {
+            return;
+        }
+        if ((0, core_1.toBoolean)(currentFileOptions["library" /* library */])) {
+            currentFileName = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(factory_1.libFolder, (0, pathUtils_1.getRelativePath)(currentFileName, normalizedBasePath)));
+        }
+        if ((0, core_1.toBoolean)(currentFileOptions["distlibrary" /* distLibrary */])) {
+            currentFileName = (0, pathUtils_1.normalizePath)((0, pathUtils_1.combinePaths)(factory_1.distlibFolder, (0, pathUtils_1.getRelativePath)(currentFileName, normalizedBasePath)));
+        }
+        const file = parseFileContent(currentFileContent, currentFileName, markerPositions, markers, ranges);
+        file.fileOptions = currentFileOptions;
+        // Store result file
+        files.push(file);
+        currentFileContent = undefined;
+        currentFileOptions = {};
+        currentFileName = fileName;
+    }
+    for (let line of lines) {
+        i++;
+        if (line.length > 0 && line.charAt(line.length - 1) === '\r') {
+            line = line.substr(0, line.length - 1);
+        }
+        if (line.substr(0, 4) === '////') {
+            const text = line.substr(4);
+            currentFileContent = currentFileContent === undefined ? text : currentFileContent + '\n' + text;
+        }
+        else if (line.substr(0, 3) === '///' && currentFileContent !== undefined) {
+            throw new Error(`Three-slash line in the middle of four-slash region at line ${i}`);
+        }
+        else if (line.substr(0, 2) === '//') {
+            // Comment line, check for global/file @options and record them
+            const match = optionRegex.exec(line.substr(2));
+            if (match) {
+                const key = match[1].toLowerCase();
+                const value = match[2];
+                if (!(0, collectionUtils_1.contains)(fourSlashTypes_1.fileMetadataNames, key)) {
+                    // Check if the match is already existed in the global options
+                    if (globalOptions[key] !== undefined) {
+                        throw new Error(`Global option '${key}' already exists`);
+                    }
+                    globalOptions[key] = value;
+                }
+                else {
+                    switch (key) {
+                        case "filename" /* fileName */: {
+                            // Found an @FileName directive, if this is not the first then create a new subfile
+                            nextFile();
+                            const normalizedPath = (0, pathUtils_1.normalizeSlashes)(value);
+                            currentFileName = (0, pathUtils_1.isRootedDiskPath)(normalizedPath)
+                                ? normalizedPath
+                                : (0, pathUtils_1.combinePaths)(normalizedBasePath, normalizedPath);
+                            currentFileOptions[key] = value;
+                            break;
+                        }
+                        default:
+                            // Add other fileMetadata flag
+                            currentFileOptions[key] = value;
+                    }
+                }
+            }
+        }
+        else if (line !== '') {
+            // Previously blank lines between fourslash content caused it to be considered as 2 files,
+            // Remove this behavior since it just causes errors now
+            //
+            // Code line, terminate current subfile if there is one
+            nextFile();
+        }
+    }
+    return {
+        markerPositions,
+        markers,
+        globalOptions,
+        files,
+        ranges,
+    };
+}
+exports.parseTestData = parseTestData;
+function reportError(fileName, line, col, message) {
+    const errorMessage = `${fileName}(${line},${col}): ${message}`;
+    throw new Error(errorMessage);
+}
+function recordObjectMarker(fileName, location, text, markerMap, markers) {
+    let markerValue;
+    try {
+        // Attempt to parse the marker value as JSON
+        markerValue = JSON.parse('{ ' + text + ' }');
+    }
+    catch (e) {
+        reportError(fileName, location.sourceLine, location.sourceColumn, `Unable to parse marker text ${e.message}`);
+    }
+    if (markerValue === undefined) {
+        reportError(fileName, location.sourceLine, location.sourceColumn, 'Object markers can not be empty');
+        return undefined;
+    }
+    const marker = {
+        fileName,
+        position: location.position,
+        data: markerValue,
+    };
+    // Object markers can be anonymous
+    if (markerValue.name) {
+        markerMap.set(markerValue.name, marker);
+    }
+    markers.push(marker);
+    return marker;
+}
+function recordMarker(fileName, location, name, markerMap, markers) {
+    const marker = {
+        fileName,
+        position: location.position,
+    };
+    // Verify markers for uniqueness
+    if (markerMap.has(name)) {
+        const message = "Marker '" + name + "' is duplicated in the source file contents.";
+        reportError(marker.fileName, location.sourceLine, location.sourceColumn, message);
+        return undefined;
+    }
+    else {
+        markerMap.set(name, marker);
+        markers.push(marker);
+        return marker;
+    }
+}
+function parseFileContent(content, fileName, markerMap, markers, ranges) {
+    content = chompLeadingSpace(content);
+    // Any slash-star comment with a character not in this string is not a marker.
+    const validMarkerChars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz$1234567890_';
+    /// The file content (minus metacharacters) so far
+    let output = '';
+    /// The current marker (or maybe multi-line comment?) we're parsing, possibly
+    let openMarker;
+    /// A stack of the open range markers that are still unclosed
+    const openRanges = [];
+    /// A list of ranges we've collected so far */
+    let localRanges = [];
+    /// The latest position of the start of an unflushed plain text area
+    let lastNormalCharPosition = 0;
+    /// The total number of metacharacters removed from the file (so far)
+    let difference = 0;
+    /// The fourslash file state object we are generating
+    let state = 0 /* none */;
+    /// Current position data
+    let line = 1;
+    let column = 1;
+    const flush = (lastSafeCharIndex) => {
+        output =
+            output +
+                content.substr(lastNormalCharPosition, lastSafeCharIndex === undefined ? undefined : lastSafeCharIndex - lastNormalCharPosition);
+    };
+    if (content.length > 0) {
+        let previousChar = content.charAt(0);
+        for (let i = 1; i < content.length; i++) {
+            const currentChar = content.charAt(i);
+            switch (state) {
+                case 0 /* none */:
+                    if (previousChar === '[' && currentChar === '|') {
+                        // found a range start
+                        openRanges.push({
+                            position: i - 1 - difference,
+                            sourcePosition: i - 1,
+                            sourceLine: line,
+                            sourceColumn: column,
+                        });
+                        // copy all text up to marker position
+                        flush(i - 1);
+                        lastNormalCharPosition = i + 1;
+                        difference += 2;
+                    }
+                    else if (previousChar === '|' && currentChar === ']') {
+                        // found a range end
+                        const rangeStart = openRanges.pop();
+                        if (!rangeStart) {
+                            reportError(fileName, line, column, 'Found range end with no matching start.');
+                        }
+                        const range = {
+                            fileName,
+                            pos: rangeStart.position,
+                            end: i - 1 - difference,
+                            marker: rangeStart.marker,
+                        };
+                        localRanges.push(range);
+                        // copy all text up to range marker position
+                        flush(i - 1);
+                        lastNormalCharPosition = i + 1;
+                        difference += 2;
+                    }
+                    else if (previousChar === '/' && currentChar === '*') {
+                        // found a possible marker start
+                        state = 1 /* inSlashStarMarker */;
+                        openMarker = {
+                            position: i - 1 - difference,
+                            sourcePosition: i - 1,
+                            sourceLine: line,
+                            sourceColumn: column,
+                        };
+                    }
+                    else if (previousChar === '{' && currentChar === '|') {
+                        // found an object marker start
+                        state = 2 /* inObjectMarker */;
+                        openMarker = {
+                            position: i - 1 - difference,
+                            sourcePosition: i - 1,
+                            sourceLine: line,
+                            sourceColumn: column,
+                        };
+                        flush(i - 1);
+                    }
+                    break;
+                case 2 /* inObjectMarker */:
+                    // Object markers are only ever terminated by |} and have no content restrictions
+                    if (previousChar === '|' && currentChar === '}') {
+                        // Record the marker
+                        const objectMarkerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
+                        const marker = recordObjectMarker(fileName, openMarker, objectMarkerNameText, markerMap, markers);
+                        if (openRanges.length > 0) {
+                            openRanges[openRanges.length - 1].marker = marker;
+                        }
+                        // Set the current start to point to the end of the current marker to ignore its text
+                        lastNormalCharPosition = i + 1;
+                        difference += i + 1 - openMarker.sourcePosition;
+                        // Reset the state
+                        openMarker = undefined;
+                        state = 0 /* none */;
+                    }
+                    break;
+                case 1 /* inSlashStarMarker */:
+                    if (previousChar === '*' && currentChar === '/') {
+                        // Record the marker
+                        // start + 2 to ignore the */, -1 on the end to ignore the * (/ is next)
+                        const markerNameText = content.substring(openMarker.sourcePosition + 2, i - 1).trim();
+                        const marker = recordMarker(fileName, openMarker, markerNameText, markerMap, markers);
+                        if (openRanges.length > 0) {
+                            openRanges[openRanges.length - 1].marker = marker;
+                        }
+                        // Set the current start to point to the end of the current marker to ignore its text
+                        flush(openMarker.sourcePosition);
+                        lastNormalCharPosition = i + 1;
+                        difference += i + 1 - openMarker.sourcePosition;
+                        // Reset the state
+                        openMarker = undefined;
+                        state = 0 /* none */;
+                    }
+                    else if (validMarkerChars.indexOf(currentChar) < 0) {
+                        if (currentChar === '*' && i < content.length - 1 && content.charAt(i + 1) === '/') {
+                            // The marker is about to be closed, ignore the 'invalid' char
+                        }
+                        else {
+                            // We've hit a non-valid marker character, so we were actually in a block comment
+                            // Bail out the text we've gathered so far back into the output
+                            flush(i);
+                            lastNormalCharPosition = i;
+                            openMarker = undefined;
+                            state = 0 /* none */;
+                        }
+                    }
+                    break;
+            }
+            if (currentChar === '\n' && previousChar === '\r') {
+                // Ignore trailing \n after a \r
+                continue;
+            }
+            else if (currentChar === '\n' || currentChar === '\r') {
+                line++;
+                column = 1;
+                continue;
+            }
+            column++;
+            previousChar = currentChar;
+        }
+    }
+    // Add the remaining text
+    flush(/*lastSafeCharIndex*/ undefined);
+    if (openRanges.length > 0) {
+        const openRange = openRanges[0];
+        reportError(fileName, openRange.sourceLine, openRange.sourceColumn, 'Unterminated range.');
+    }
+    if (openMarker) {
+        reportError(fileName, openMarker.sourceLine, openMarker.sourceColumn, 'Unterminated marker.');
+    }
+    // put ranges in the correct order
+    localRanges = localRanges.sort((a, b) => (a.pos < b.pos ? -1 : a.pos === b.pos && a.end > b.end ? -1 : 1));
+    localRanges.forEach((r) => {
+        ranges.push(r);
+    });
+    return {
+        content: output,
+        fileOptions: {},
+        version: 0,
+        fileName,
+    };
+}
+function chompLeadingSpace(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        if (line.length !== 0 && line.charAt(0) !== ' ') {
+            return content;
+        }
+    }
+    return lines.map((s) => s.substr(1)).join('\n');
+}
+//# sourceMappingURL=fourSlashParser.js.map