@tslite/parser 1.9.0 → 1.12.0

package/dist/path.js

@@ -0,0 +1,475 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/path.ts: o namespace virou módulo ES, com os imports explícitos.
+import { Debug, compareStringsCaseInsensitive, compareValues, endsWith, equateStringsCaseInsensitive, equateStringsCaseSensitive, getStringComparer, identity, lastOrUndefined, some, startsWith, } from "./_namespaces/ts.js";
+/**
+ * Internally, we represent paths as strings with '/' as the directory separator.
+ * When we make system calls (eg: LanguageServiceHost.getDirectory()),
+ * we expect the host to correctly handle paths in our specified format.
+ */
+export const directorySeparator = "/";
+const altDirectorySeparator = "\\";
+const urlSchemeSeparator = "://";
+const backslashRegExp = /\\/g;
+//// Path Tests
+/**
+ * Determines whether a charCode corresponds to `/` or `\`.
+ */
+export function isAnyDirectorySeparator(charCode) {
+    return charCode === 47 /* CharacterCodes.slash */ || charCode === 92 /* CharacterCodes.backslash */;
+}
+/**
+ * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path
+ * like `c:`, `c:\` or `c:/`).
+ */
+export function isRootedDiskPath(path) {
+    return getEncodedRootLength(path) > 0;
+}
+/**
+ * Determines whether a path starts with an absolute path component (i.e. `/`, `c:/`, `file://`, etc.).
+ *
+ * ```ts
+ * // POSIX
+ * pathIsAbsolute("/path/to/file.ext") === true
+ * // DOS
+ * pathIsAbsolute("c:/path/to/file.ext") === true
+ * // URL
+ * pathIsAbsolute("file:///path/to/file.ext") === true
+ * // Non-absolute
+ * pathIsAbsolute("path/to/file.ext") === false
+ * pathIsAbsolute("./path/to/file.ext") === false
+ * ```
+ */
+export function pathIsAbsolute(path) {
+    return getEncodedRootLength(path) !== 0;
+}
+/**
+ * Determines whether a path starts with a relative path component (i.e. `.` or `..`).
+ */
+export function pathIsRelative(path) {
+    return /^\.\.?($|[\\/])/.test(path);
+}
+export function fileExtensionIs(path, extension) {
+    return path.length > extension.length && endsWith(path, extension);
+}
+/**
+ * Determines whether a path has a trailing separator (`/` or `\\`).
+ */
+export function hasTrailingDirectorySeparator(path) {
+    return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1));
+}
+//// Path Parsing
+function isVolumeCharacter(charCode) {
+    return (charCode >= 97 /* CharacterCodes.a */ && charCode <= 122 /* CharacterCodes.z */) ||
+        (charCode >= 65 /* CharacterCodes.A */ && charCode <= 90 /* CharacterCodes.Z */);
+}
+function getFileUrlVolumeSeparatorEnd(url, start) {
+    const ch0 = url.charCodeAt(start);
+    if (ch0 === 58 /* CharacterCodes.colon */)
+        return start + 1;
+    if (ch0 === 37 /* CharacterCodes.percent */ && url.charCodeAt(start + 1) === 51 /* CharacterCodes._3 */) {
+        const ch2 = url.charCodeAt(start + 2);
+        if (ch2 === 97 /* CharacterCodes.a */ || ch2 === 65 /* CharacterCodes.A */)
+            return start + 3;
+    }
+    return -1;
+}
+/**
+ * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+ * If the root is part of a URL, the twos-complement of the root length is returned.
+ */
+function getEncodedRootLength(path) {
+    if (!path)
+        return 0;
+    const ch0 = path.charCodeAt(0);
+    // POSIX or UNC
+    if (ch0 === 47 /* CharacterCodes.slash */ || ch0 === 92 /* CharacterCodes.backslash */) {
+        if (path.charCodeAt(1) !== ch0)
+            return 1; // POSIX: "/" (or non-normalized "\")
+        const p1 = path.indexOf(ch0 === 47 /* CharacterCodes.slash */ ? directorySeparator : altDirectorySeparator, 2);
+        if (p1 < 0)
+            return path.length; // UNC: "//server" or "\\server"
+        return p1 + 1; // UNC: "//server/" or "\\server\"
+    }
+    // DOS
+    if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* CharacterCodes.colon */) {
+        const ch2 = path.charCodeAt(2);
+        if (ch2 === 47 /* CharacterCodes.slash */ || ch2 === 92 /* CharacterCodes.backslash */)
+            return 3; // DOS: "c:/" or "c:\"
+        if (path.length === 2)
+            return 2; // DOS: "c:" (but not "c:d")
+    }
+    // URL
+    const schemeEnd = path.indexOf(urlSchemeSeparator);
+    if (schemeEnd !== -1) {
+        const authorityStart = schemeEnd + urlSchemeSeparator.length;
+        const authorityEnd = path.indexOf(directorySeparator, authorityStart);
+        if (authorityEnd !== -1) { // URL: "file:///", "file://server/", "file://server/path"
+            // For local "file" URLs, include the leading DOS volume (if present).
+            // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a
+            // special case interpreted as "the machine from which the URL is being interpreted".
+            const scheme = path.slice(0, schemeEnd);
+            const authority = path.slice(authorityStart, authorityEnd);
+            if (scheme === "file" && (authority === "" || authority === "localhost") &&
+                isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) {
+                const volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2);
+                if (volumeSeparatorEnd !== -1) {
+                    if (path.charCodeAt(volumeSeparatorEnd) === 47 /* CharacterCodes.slash */) {
+                        // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/"
+                        return ~(volumeSeparatorEnd + 1);
+                    }
+                    if (volumeSeparatorEnd === path.length) {
+                        // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a"
+                        // but not "file:///c:d" or "file:///c%3ad"
+                        return ~volumeSeparatorEnd;
+                    }
+                }
+            }
+            return ~(authorityEnd + 1); // URL: "file://server/", "http://server/"
+        }
+        return ~path.length; // URL: "file://server", "http://server"
+    }
+    // relative
+    return 0;
+}
+/**
+ * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files").
+ *
+ * For example:
+ * ```ts
+ * getRootLength("a") === 0                   // ""
+ * getRootLength("/") === 1                   // "/"
+ * getRootLength("c:") === 2                  // "c:"
+ * getRootLength("c:d") === 0                 // ""
+ * getRootLength("c:/") === 3                 // "c:/"
+ * getRootLength("c:\\") === 3                // "c:\\"
+ * getRootLength("//server") === 7            // "//server"
+ * getRootLength("//server/share") === 8      // "//server/"
+ * getRootLength("\\\\server") === 7          // "\\\\server"
+ * getRootLength("\\\\server\\share") === 8   // "\\\\server\\"
+ * getRootLength("file:///path") === 8        // "file:///"
+ * getRootLength("file:///c:") === 10         // "file:///c:"
+ * getRootLength("file:///c:d") === 8         // "file:///"
+ * getRootLength("file:///c:/path") === 11    // "file:///c:/"
+ * getRootLength("file://server") === 13      // "file://server"
+ * getRootLength("file://server/path") === 14 // "file://server/"
+ * getRootLength("http://server") === 13      // "http://server"
+ * getRootLength("http://server/path") === 14 // "http://server/"
+ * ```
+ */
+export function getRootLength(path) {
+    const rootLength = getEncodedRootLength(path);
+    return rootLength < 0 ? ~rootLength : rootLength;
+}
+export function getDirectoryPath(path) {
+    path = normalizeSlashes(path);
+    // If the path provided is itself the root, then return it.
+    const rootLength = getRootLength(path);
+    if (rootLength === path.length)
+        return path;
+    // return the leading portion of the path up to the last (non-terminal) directory separator
+    // but not including any trailing directory separator.
+    path = removeTrailingDirectorySeparator(path);
+    return path.slice(0, Math.max(rootLength, path.lastIndexOf(directorySeparator)));
+}
+export function getBaseFileName(path, extensions, ignoreCase) {
+    path = normalizeSlashes(path);
+    // if the path provided is itself the root, then it has not file name.
+    const rootLength = getRootLength(path);
+    if (rootLength === path.length)
+        return "";
+    // return the trailing portion of the path starting after the last (non-terminal) directory
+    // separator but not including any trailing directory separator.
+    path = removeTrailingDirectorySeparator(path);
+    const name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(directorySeparator) + 1));
+    const extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined;
+    return extension ? name.slice(0, name.length - extension.length) : name;
+}
+function tryGetExtensionFromPath(path, extension, stringEqualityComparer) {
+    if (!startsWith(extension, "."))
+        extension = "." + extension;
+    if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* CharacterCodes.dot */) {
+        const pathExtension = path.slice(path.length - extension.length);
+        if (stringEqualityComparer(pathExtension, extension)) {
+            return pathExtension;
+        }
+    }
+}
+function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) {
+    if (typeof extensions === "string") {
+        return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || "";
+    }
+    for (const extension of extensions) {
+        const result = tryGetExtensionFromPath(path, extension, stringEqualityComparer);
+        if (result)
+            return result;
+    }
+    return "";
+}
+export function getAnyExtensionFromPath(path, extensions, ignoreCase) {
+    // Retrieves any string from the final "." onwards from a base file name.
+    // Unlike extensionFromPath, which throws an exception on unrecognized extensions.
+    if (extensions) {
+        return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive);
+    }
+    const baseFileName = getBaseFileName(path);
+    const extensionIndex = baseFileName.lastIndexOf(".");
+    if (extensionIndex >= 0) {
+        return baseFileName.substring(extensionIndex);
+    }
+    return "";
+}
+function pathComponents(path, rootLength) {
+    const root = path.substring(0, rootLength);
+    const rest = path.substring(rootLength).split(directorySeparator);
+    if (rest.length && !lastOrUndefined(rest))
+        rest.pop();
+    return [root, ...rest];
+}
+/**
+ * Parse a path into an array containing a root component (at index 0) and zero or more path
+ * components (at indices > 0). The result is not normalized.
+ * If the path is relative, the root component is `""`.
+ * If the path is absolute, the root component includes the first path separator (`/`).
+ *
+ * ```ts
+ * // POSIX
+ * getPathComponents("/path/to/file.ext") === ["/", "path", "to", "file.ext"]
+ * getPathComponents("/path/to/") === ["/", "path", "to"]
+ * getPathComponents("/") === ["/"]
+ * // DOS
+ * getPathComponents("c:/path/to/file.ext") === ["c:/", "path", "to", "file.ext"]
+ * getPathComponents("c:/path/to/") === ["c:/", "path", "to"]
+ * getPathComponents("c:/") === ["c:/"]
+ * getPathComponents("c:") === ["c:"]
+ * // URL
+ * getPathComponents("http://typescriptlang.org/path/to/file.ext") === ["http://typescriptlang.org/", "path", "to", "file.ext"]
+ * getPathComponents("http://typescriptlang.org/path/to/") === ["http://typescriptlang.org/", "path", "to"]
+ * getPathComponents("http://typescriptlang.org/") === ["http://typescriptlang.org/"]
+ * getPathComponents("http://typescriptlang.org") === ["http://typescriptlang.org"]
+ * getPathComponents("file://server/path/to/file.ext") === ["file://server/", "path", "to", "file.ext"]
+ * getPathComponents("file://server/path/to/") === ["file://server/", "path", "to"]
+ * getPathComponents("file://server/") === ["file://server/"]
+ * getPathComponents("file://server") === ["file://server"]
+ * getPathComponents("file:///path/to/file.ext") === ["file:///", "path", "to", "file.ext"]
+ * getPathComponents("file:///path/to/") === ["file:///", "path", "to"]
+ * getPathComponents("file:///") === ["file:///"]
+ * getPathComponents("file://") === ["file://"]
+ */
+export function getPathComponents(path, currentDirectory = "") {
+    path = combinePaths(currentDirectory, path);
+    return pathComponents(path, getRootLength(path));
+}
+//// Path Formatting
+/**
+ * Formats a parsed path consisting of a root component (at index 0) and zero or more path
+ * segments (at indices > 0).
+ *
+ * ```ts
+ * getPathFromPathComponents(["/", "path", "to", "file.ext"]) === "/path/to/file.ext"
+ * ```
+ */
+export function getPathFromPathComponents(pathComponents) {
+    if (pathComponents.length === 0)
+        return "";
+    const root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]);
+    return root + pathComponents.slice(1).join(directorySeparator);
+}
+//// Path Normalization
+/**
+ * Normalize path separators, converting `\` into `/`.
+ */
+export function normalizeSlashes(path) {
+    return path.replace(backslashRegExp, directorySeparator);
+}
+/**
+ * Reduce an array of path components to a more simplified path by navigating any
+ * `"."` or `".."` entries in the path.
+ */
+export function reducePathComponents(components) {
+    if (!some(components))
+        return [];
+    const reduced = [components[0]];
+    for (let i = 1; i < components.length; i++) {
+        const component = components[i];
+        if (!component)
+            continue;
+        if (component === ".")
+            continue;
+        if (component === "..") {
+            if (reduced.length > 1) {
+                if (reduced[reduced.length - 1] !== "..") {
+                    reduced.pop();
+                    continue;
+                }
+            }
+            else if (reduced[0])
+                continue;
+        }
+        reduced.push(component);
+    }
+    return reduced;
+}
+/**
+ * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified.
+ *
+ * ```ts
+ * // Non-rooted
+ * combinePaths("path", "to", "file.ext") === "path/to/file.ext"
+ * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext"
+ * // POSIX
+ * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext"
+ * combinePaths("/path", "/to", "file.ext") === "/to/file.ext"
+ * // DOS
+ * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext"
+ * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext"
+ * // URL
+ * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext"
+ * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext"
+ * ```
+ */
+export function combinePaths(path, ...paths) {
+    if (path)
+        path = normalizeSlashes(path);
+    for (let relativePath of paths) {
+        if (!relativePath)
+            continue;
+        relativePath = normalizeSlashes(relativePath);
+        if (!path || getRootLength(relativePath) !== 0) {
+            path = relativePath;
+        }
+        else {
+            path = ensureTrailingDirectorySeparator(path) + relativePath;
+        }
+    }
+    return path;
+}
+/**
+ * Parse a path into an array containing a root component (at index 0) and zero or more path
+ * components (at indices > 0). The result is normalized.
+ * If the path is relative, the root component is `""`.
+ * If the path is absolute, the root component includes the first path separator (`/`).
+ *
+ * ```ts
+ * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"]
+ * ```
+ */
+export function getNormalizedPathComponents(path, currentDirectory) {
+    return reducePathComponents(getPathComponents(path, currentDirectory));
+}
+export function getNormalizedAbsolutePath(fileName, currentDirectory) {
+    return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory));
+}
+export function normalizePath(path) {
+    path = normalizeSlashes(path);
+    const normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path)));
+    return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized;
+}
+export function toPath(fileName, basePath, getCanonicalFileName) {
+    const nonCanonicalizedPath = isRootedDiskPath(fileName)
+        ? normalizePath(fileName)
+        : getNormalizedAbsolutePath(fileName, basePath);
+    return getCanonicalFileName(nonCanonicalizedPath);
+}
+export function removeTrailingDirectorySeparator(path) {
+    if (hasTrailingDirectorySeparator(path)) {
+        return path.substr(0, path.length - 1);
+    }
+    return path;
+}
+export function ensureTrailingDirectorySeparator(path) {
+    if (!hasTrailingDirectorySeparator(path)) {
+        return path + directorySeparator;
+    }
+    return path;
+}
+/**
+ * Ensures a path is either absolute (prefixed with `/` or `c:`) or dot-relative (prefixed
+ * with `./` or `../`) so as not to be confused with an unprefixed module name.
+ *
+ * ```ts
+ * ensurePathIsNonModuleName("/path/to/file.ext") === "/path/to/file.ext"
+ * ensurePathIsNonModuleName("./path/to/file.ext") === "./path/to/file.ext"
+ * ensurePathIsNonModuleName("../path/to/file.ext") === "../path/to/file.ext"
+ * ensurePathIsNonModuleName("path/to/file.ext") === "./path/to/file.ext"
+ * ```
+ */
+export function ensurePathIsNonModuleName(path) {
+    return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path;
+}
+//// Path Comparisons
+// check path for these segments: '', '.'. '..'
+const relativePathSegmentRegExp = /(^|\/)\.{0,2}($|\/)/;
+function comparePathsWorker(a, b, componentComparer) {
+    if (a === b)
+        return 0 /* Comparison.EqualTo */;
+    if (a === undefined)
+        return -1 /* Comparison.LessThan */;
+    if (b === undefined)
+        return 1 /* Comparison.GreaterThan */;
+    // NOTE: Performance optimization - shortcut if the root segments differ as there would be no
+    //       need to perform path reduction.
+    const aRoot = a.substring(0, getRootLength(a));
+    const bRoot = b.substring(0, getRootLength(b));
+    const result = compareStringsCaseInsensitive(aRoot, bRoot);
+    if (result !== 0 /* Comparison.EqualTo */) {
+        return result;
+    }
+    // NOTE: Performance optimization - shortcut if there are no relative path segments in
+    //       the non-root portion of the path
+    const aRest = a.substring(aRoot.length);
+    const bRest = b.substring(bRoot.length);
+    if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) {
+        return componentComparer(aRest, bRest);
+    }
+    // The path contains a relative path segment. Normalize the paths and perform a slower component
+    // by component comparison.
+    const aComponents = reducePathComponents(getPathComponents(a));
+    const bComponents = reducePathComponents(getPathComponents(b));
+    const sharedLength = Math.min(aComponents.length, bComponents.length);
+    for (let i = 1; i < sharedLength; i++) {
+        const result = componentComparer(aComponents[i], bComponents[i]);
+        if (result !== 0 /* Comparison.EqualTo */) {
+            return result;
+        }
+    }
+    return compareValues(aComponents.length, bComponents.length);
+}
+export function comparePaths(a, b, currentDirectory, ignoreCase) {
+    if (typeof currentDirectory === "string") {
+        a = combinePaths(currentDirectory, a);
+        b = combinePaths(currentDirectory, b);
+    }
+    else if (typeof currentDirectory === "boolean") {
+        ignoreCase = currentDirectory;
+    }
+    return comparePathsWorker(a, b, getStringComparer(ignoreCase));
+}
+//// Relative Paths
+export function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) {
+    const fromComponents = reducePathComponents(getPathComponents(from));
+    const toComponents = reducePathComponents(getPathComponents(to));
+    let start;
+    for (start = 0; start < fromComponents.length && start < toComponents.length; start++) {
+        const fromComponent = getCanonicalFileName(fromComponents[start]);
+        const toComponent = getCanonicalFileName(toComponents[start]);
+        const comparer = start === 0 ? equateStringsCaseInsensitive : stringEqualityComparer;
+        if (!comparer(fromComponent, toComponent))
+            break;
+    }
+    if (start === 0) {
+        return toComponents;
+    }
+    const components = toComponents.slice(start);
+    const relative = [];
+    for (; start < fromComponents.length; start++) {
+        relative.push("..");
+    }
+    return ["", ...relative, ...components];
+}
+export function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) {
+    Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative");
+    const getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : identity;
+    const ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false;
+    const pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? equateStringsCaseInsensitive : equateStringsCaseSensitive, getCanonicalFileName);
+    return getPathFromPathComponents(pathComponents);
+}
+//// Path Traversal

package/dist/perfLogger.d.ts

@@ -0,0 +1,4 @@
+type PerfLogger = typeof import("@microsoft/typescript-etw");
+/** Performance logger that will generate ETW events if possible - check for `logEvent` member, as `etwModule` will be `{}` when browserified */
+export declare const perfLogger: PerfLogger;
+export {};

package/dist/perfLogger.js

@@ -0,0 +1,38 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/perfLogger.ts: o namespace virou módulo ES, com os imports explícitos.
+import { noop, } from "./_namespaces/ts.js";
+const nullLogger = {
+    logEvent: noop,
+    logErrEvent: noop,
+    logPerfEvent: noop,
+    logInfoEvent: noop,
+    logStartCommand: noop,
+    logStopCommand: noop,
+    logStartUpdateProgram: noop,
+    logStopUpdateProgram: noop,
+    logStartUpdateGraph: noop,
+    logStopUpdateGraph: noop,
+    logStartResolveModule: noop,
+    logStopResolveModule: noop,
+    logStartParseSourceFile: noop,
+    logStopParseSourceFile: noop,
+    logStartReadFile: noop,
+    logStopReadFile: noop,
+    logStartBindFile: noop,
+    logStopBindFile: noop,
+    logStartScheduledOperation: noop,
+    logStopScheduledOperation: noop,
+};
+// Load optional module to enable Event Tracing for Windows
+// See https://github.com/microsoft/typescript-etw for more information
+let etwModule;
+try {
+    const etwModulePath = process.env.TS_ETW_MODULE_PATH ?? "./node_modules/@microsoft/typescript-etw";
+    // require() will throw an exception if the module is not found
+    // It may also return undefined if not installed properly
+    etwModule = require(etwModulePath);
+}
+catch (e) {
+    etwModule = undefined;
+}
+/** Performance logger that will generate ETW events if possible - check for `logEvent` member, as `etwModule` will be `{}` when browserified */
+export const perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger;

package/dist/performance.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Marks a performance event.
+ *
+ * @param markName The name of the mark.
+ */
+export declare function mark(markName: string): void;
+/**
+ * Adds a performance measurement with the specified name.
+ *
+ * @param measureName The name of the performance measurement.
+ * @param startMarkName The name of the starting mark. If not supplied, the point at which the
+ *      profiler was enabled is used.
+ * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is
+ *      used.
+ */
+export declare function measure(measureName: string, startMarkName?: string, endMarkName?: string): void;
+/** Enables (and resets) performance measurements for the compiler. */
+export declare function enable(): void;
+/** Disables performance measurements for the compiler. */
+export declare function disable(): void;

package/dist/performance.js

@@ -0,0 +1,49 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/performance.ts: o namespace virou módulo ES, com os imports explícitos.
+import { createMap, timestamp, } from "./_namespaces/ts.js";
+// NOTE: cannot use ts.noop as core.ts loads after this
+const profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true ? onProfilerEvent : () => { };
+let enabled = false;
+let profilerStart = 0;
+let counts;
+let marks;
+let measures;
+/**
+ * Marks a performance event.
+ *
+ * @param markName The name of the mark.
+ */
+export function mark(markName) {
+    if (enabled) {
+        marks.set(markName, timestamp());
+        counts.set(markName, (counts.get(markName) || 0) + 1);
+        profilerEvent(markName);
+    }
+}
+/**
+ * Adds a performance measurement with the specified name.
+ *
+ * @param measureName The name of the performance measurement.
+ * @param startMarkName The name of the starting mark. If not supplied, the point at which the
+ *      profiler was enabled is used.
+ * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is
+ *      used.
+ */
+export function measure(measureName, startMarkName, endMarkName) {
+    if (enabled) {
+        const end = endMarkName && marks.get(endMarkName) || timestamp();
+        const start = startMarkName && marks.get(startMarkName) || profilerStart;
+        measures.set(measureName, (measures.get(measureName) || 0) + (end - start));
+    }
+}
+/** Enables (and resets) performance measurements for the compiler. */
+export function enable() {
+    counts = createMap();
+    marks = createMap();
+    measures = createMap();
+    enabled = true;
+    profilerStart = timestamp();
+}
+/** Disables performance measurements for the compiler. */
+export function disable() {
+    enabled = false;
+}

package/dist/performanceTimestamp.d.ts

@@ -0,0 +1,2 @@
+/** Gets a timestamp with (at least) ms resolution */
+export declare const timestamp: () => number;

package/dist/performanceTimestamp.js

@@ -0,0 +1,2 @@
+/** Gets a timestamp with (at least) ms resolution */
+export const timestamp = typeof performance !== "undefined" && performance.now ? () => performance.now() : Date.now ? Date.now : () => +(new Date());