tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/vfs-match.js

@@ -0,0 +1,587 @@
+/**
+ * `include`/`exclude` glob matching and directory traversal, without regular expressions.
+ *
+ * ```ts
+ * const files = readDirectory(fs, '/app', '/app', ['.ts'], ['node_modules'], ['src/**\/*'], unlimitedDepth);
+ * ```
+ */
+import { compareCodePoints } from './diagnostics.js';
+import { combinePaths, compareStringsCaseInsensitive, containsPath, equateStringsCaseInsensitive, fileExtensionIsOneOf, getBaseFileName, getCanonicalFileName, getDirectoryPath, getPathComponents, isRootedDiskPath, normalizePath, reducePathComponents, removeTrailingDirectorySeparator, } from './path.js';
+/** A depth for `readDirectory` without a limit. */
+export const unlimitedDepth = Number.MAX_SAFE_INTEGER;
+/** Whether an `include` component without an extension or wildcard stands for `component/**\/*`. */
+export function isImplicitGlob(lastPathComponent) {
+    for (let i = 0; i < lastPathComponent.length; i++) {
+        const ch = lastPathComponent.charCodeAt(i);
+        if (ch === 0x2e /* . */ || ch === 0x2a /* * */ || ch === 0x3f /* ? */)
+            return false;
+    }
+    return true;
+}
+function hasWildcard(text) {
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        if (ch === 0x2a || ch === 0x3f)
+            return true;
+    }
+    return false;
+}
+/** Files under `path` with one of `extensions` matched by `includes` and not `excludes`, grouped by the first matching include. */
+export function readDirectory(fs, currentDirectory, path, extensions, excludes, includes, depth, onMatch) {
+    path = normalizePath(path);
+    currentDirectory = normalizePath(currentDirectory);
+    const absolutePath = combinePaths(currentDirectory, path);
+    const caseSensitive = fs.useCaseSensitiveFileNames;
+    const visitor = new GlobVisitor(fs, new GlobMatcher(includes, excludes, absolutePath, caseSensitive, 0 /* MatchUsage.Files */), new GlobMatcher(includes, excludes, absolutePath, caseSensitive, 1 /* MatchUsage.Directories */), extensions, onMatch);
+    for (const basePath of getBasePaths(path, includes, caseSensitive)) {
+        visitor.visit(basePath, combinePaths(currentDirectory, basePath), depth, '');
+    }
+    const results = visitor.results;
+    if (results.length === 1)
+        return results[0];
+    const flat = [];
+    for (const bucket of results)
+        for (const file of bucket)
+            flat.push(file);
+    return flat;
+}
+/** Matches paths against any of several specs. */
+export class SpecMatcher {
+    patterns;
+    constructor(patterns) {
+        this.patterns = patterns;
+    }
+    /** `undefined` when no spec can match anything. */
+    static create(specs, basePath, usage, useCaseSensitiveFileNames) {
+        const patterns = [];
+        for (const spec of specs) {
+            const pattern = GlobPattern.compile(spec, basePath, usage, useCaseSensitiveFileNames);
+            if (pattern !== undefined)
+                patterns.push(pattern);
+        }
+        return patterns.length === 0 ? undefined : new SpecMatcher(patterns);
+    }
+    matches(path) {
+        return this.matchIndex(path) !== -1;
+    }
+    /** Index of the first matching pattern, or -1. */
+    matchIndex(path) {
+        for (let i = 0; i < this.patterns.length; i++)
+            if (this.patterns[i].matches(path, '', false))
+                return i;
+        return -1;
+    }
+}
+// ---- Base paths
+function getIncludeBasePath(absolute) {
+    let wildcard = -1;
+    for (let i = 0; i < absolute.length; i++) {
+        const ch = absolute.charCodeAt(i);
+        if (ch === 0x2a || ch === 0x3f) {
+            wildcard = i;
+            break;
+        }
+    }
+    if (wildcard < 0) {
+        return hasExtension(absolute) ? removeTrailingDirectorySeparator(getDirectoryPath(absolute)) : absolute;
+    }
+    return absolute.slice(0, Math.max(absolute.lastIndexOf('/', wildcard - 1), 0));
+}
+/** Whether the base name of `path` has a `.`. */
+export function hasExtension(path) {
+    return getBaseFileName(path).includes('.');
+}
+/** `path` and the literal prefixes of `includes` that are not inside it or each other. */
+function getBasePaths(path, includes, caseSensitive) {
+    const basePaths = [path];
+    if (includes.length === 0)
+        return basePaths;
+    const includeBasePaths = [];
+    for (const include of includes) {
+        const absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
+        includeBasePaths.push(getIncludeBasePath(absolute));
+    }
+    includeBasePaths.sort(caseSensitive ? compareCodePoints : compareStringsCaseInsensitive);
+    for (const includeBasePath of includeBasePaths) {
+        let contained = false;
+        for (const basePath of basePaths) {
+            if (containsPath(basePath, includeBasePath, caseSensitive, path)) {
+                contained = true;
+                break;
+            }
+        }
+        if (!contained)
+            basePaths.push(includeBasePath);
+    }
+    return basePaths;
+}
+class Segment {
+    kind;
+    literal;
+    constructor(kind, literal) {
+        this.kind = kind;
+        this.literal = literal;
+    }
+}
+class Component {
+    kind;
+    literal;
+    segments;
+    skipPackageFolders;
+    mentionsMinSuffix;
+    constructor(kind, literal, segments, 
+    /** Include wildcards don't match `node_modules`, `bower_components` or `jspm_packages`. */
+    skipPackageFolders, 
+    /** A literal segment mentions `.min.`, so `.min.js` files aren't skipped. */
+    mentionsMinSuffix) {
+        this.kind = kind;
+        this.literal = literal;
+        this.segments = segments;
+        this.skipPackageFolders = skipPackageFolders;
+        this.mentionsMinSuffix = mentionsMinSuffix;
+    }
+}
+function parseComponent(text, isInclude, caseSensitive) {
+    if (text === '**')
+        return new Component(2 /* ComponentKind.DoubleAsterisk */, '', [], false, false);
+    if (!hasWildcard(text))
+        return new Component(0 /* ComponentKind.Literal */, text, [], false, false);
+    const segments = [];
+    let mentionsMinSuffix = false;
+    let start = 0;
+    for (let i = 0; i <= text.length; i++) {
+        const ch = i < text.length ? text.charCodeAt(i) : -1;
+        if (ch !== 0x2a && ch !== 0x3f && ch !== -1)
+            continue;
+        if (i > start) {
+            const literal = text.slice(start, i);
+            if ((caseSensitive ? literal : literal.toLowerCase()).includes('.min.'))
+                mentionsMinSuffix = true;
+            segments.push(new Segment(0 /* SegmentKind.Literal */, literal));
+        }
+        if (ch !== -1)
+            segments.push(new Segment(ch === 0x2a ? 1 /* SegmentKind.Star */ : 2 /* SegmentKind.Question */, ''));
+        start = i + 1;
+    }
+    return new Component(1 /* ComponentKind.Wildcard */, '', segments, isInclude, mentionsMinSuffix);
+}
+/**
+ * Reads the components of `prefix + suffix` without concatenating them, where `prefix` is empty or
+ * a directory ending in `/` and `suffix` is a single name. `read` sets `text`, `start` and `end` to the
+ * component and `next` to the offset after it, in combined coordinates.
+ */
+class PathReader {
+    text = '';
+    start = 0;
+    end = 0;
+    next = 0;
+    read(prefix, suffix, offset) {
+        if (suffix === '')
+            return this.readSingle(prefix, offset, 0);
+        if (prefix === '')
+            return this.readSingle(suffix, offset, 0);
+        if (offset >= prefix.length + suffix.length)
+            return false;
+        if (offset === 0 && prefix.charCodeAt(0) === 0x2f)
+            return this.found(prefix, 0, 0, 1);
+        if (offset < prefix.length) {
+            while (offset < prefix.length && prefix.charCodeAt(offset) === 0x2f)
+                offset++;
+            if (offset < prefix.length) {
+                const end = prefix.indexOf('/', offset);
+                return this.found(prefix, offset, end, end);
+            }
+        }
+        const start = offset - prefix.length;
+        if (start >= suffix.length)
+            return false;
+        return this.found(suffix, start, suffix.length, prefix.length + suffix.length);
+    }
+    /** Reads from `text`, whose offset 0 is `base` in combined coordinates. */
+    readSingle(text, offset, base) {
+        if (offset >= text.length)
+            return false;
+        if (offset === 0 && text.charCodeAt(0) === 0x2f)
+            return this.found(text, 0, 0, base + 1);
+        while (offset < text.length && text.charCodeAt(offset) === 0x2f)
+            offset++;
+        if (offset >= text.length)
+            return false;
+        let end = text.indexOf('/', offset);
+        if (end === -1)
+            end = text.length;
+        return this.found(text, offset, end, base + end);
+    }
+    found(text, start, end, next) {
+        this.text = text;
+        this.start = start;
+        this.end = end;
+        this.next = next;
+        return true;
+    }
+}
+/** The components a pattern can be at after the directory `prefix` (`GlobPattern.frontierFrom`). */
+class Frontier {
+    /** The directory, ending in `/`; `undefined` before the first. */
+    prefix = undefined;
+    indices = [];
+    /** Whether matching ended with a match within `prefix`. */
+    matched = false;
+}
+/** A compiled glob spec such as `src/**\/*.ts`. */
+class GlobPattern {
+    components;
+    isExclude;
+    caseSensitive;
+    excludeMinJs;
+    reader = new PathReader();
+    /** Where matching files, and directories (`prefixOnly`), of the last directory got to. */
+    fileFrontier = new Frontier();
+    directoryFrontier = new Frontier();
+    constructor(components, isExclude, caseSensitive, 
+    /** `files` patterns skip `.min.js` files unless the pattern mentions them. */
+    excludeMinJs) {
+        this.components = components;
+        this.isExclude = isExclude;
+        this.caseSensitive = caseSensitive;
+        this.excludeMinJs = excludeMinJs;
+    }
+    /** `undefined` if the spec matches nothing. */
+    static compile(spec, basePath, usage, caseSensitive) {
+        const parts = reducePathComponents(getPathComponents(spec, basePath));
+        if (usage !== 2 /* MatchUsage.Exclude */ && parts[parts.length - 1] === '**')
+            return undefined;
+        parts[0] = removeTrailingDirectorySeparator(parts[0]);
+        if (isImplicitGlob(parts[parts.length - 1]))
+            parts.push('**', '*');
+        const isInclude = usage !== 2 /* MatchUsage.Exclude */;
+        const components = [];
+        for (const part of parts)
+            components.push(parseComponent(part, isInclude, caseSensitive));
+        return new GlobPattern(components, !isInclude, caseSensitive, usage === 0 /* MatchUsage.Files */);
+    }
+    /** Whether `prefix + suffix` matches, or with `prefixOnly`, whether files below it could. */
+    matches(prefix, suffix, prefixOnly) {
+        if (prefix.charCodeAt(prefix.length - 1) !== 0x2f || suffix === '')
+            return this.matchFrom(prefix, suffix, 0, 0, prefixOnly);
+        // The names of a directory share its prefix: matching goes through it once, to the components
+        // matching can be at when it reaches the name.
+        const frontier = prefixOnly ? this.directoryFrontier : this.fileFrontier;
+        if (frontier.prefix !== prefix) {
+            frontier.prefix = prefix;
+            frontier.indices.length = 0;
+            frontier.matched = this.frontierFrom(prefix, 0, 0, prefixOnly, frontier.indices);
+        }
+        if (frontier.matched)
+            return true;
+        for (const index of frontier.indices)
+            if (this.matchFrom(prefix, suffix, prefix.length, index, prefixOnly))
+                return true;
+        return false;
+    }
+    /**
+     * `matchFrom` over the components of `prefix`, a directory ending in `/`, up to the name after it:
+     * adds to `indices` the components matching can be at there, and returns whether matching ends with a
+     * match before it.
+     */
+    frontierFrom(prefix, offset, index, prefixOnly, indices) {
+        const reader = this.reader;
+        const components = this.components;
+        for (;;) {
+            // Any name after `prefix` reads the same components of it.
+            if (!reader.read(prefix, '*', offset))
+                return false;
+            if (reader.next > prefix.length) {
+                if (!indices.includes(index))
+                    indices.push(index);
+                return false;
+            }
+            if (index >= components.length)
+                return this.isExclude && !prefixOnly;
+            const text = reader.text;
+            const start = reader.start;
+            const end = reader.end;
+            const next = reader.next;
+            const component = components[index];
+            if (component.kind === 2 /* ComponentKind.DoubleAsterisk */) {
+                if (this.frontierFrom(prefix, offset, index + 1, prefixOnly, indices))
+                    return true;
+                if (!this.isExclude && (isHidden(text, start, end) || isPackageFolder(text, start, end)))
+                    return false;
+                offset = next;
+                continue;
+            }
+            if (component.kind === 0 /* ComponentKind.Literal */) {
+                if (!this.equalAt(component.literal, text, start, end))
+                    return false;
+            }
+            else {
+                if (component.skipPackageFolders && isPackageFolder(text, start, end))
+                    return false;
+                if (!this.matchWildcard(component, text, start, end))
+                    return false;
+            }
+            offset = next;
+            index++;
+        }
+    }
+    matchFrom(prefix, suffix, offset, index, prefixOnly) {
+        const reader = this.reader;
+        const components = this.components;
+        for (;;) {
+            if (!reader.read(prefix, suffix, offset))
+                return prefixOnly || this.satisfiedFrom(index);
+            if (index >= components.length)
+                return this.isExclude && !prefixOnly;
+            const text = reader.text;
+            const start = reader.start;
+            const end = reader.end;
+            const next = reader.next;
+            const component = components[index];
+            if (component.kind === 2 /* ComponentKind.DoubleAsterisk */) {
+                if (this.matchFrom(prefix, suffix, offset, index + 1, prefixOnly))
+                    return true;
+                if (!this.isExclude && (isHidden(text, start, end) || isPackageFolder(text, start, end)))
+                    return false;
+                offset = next;
+                continue;
+            }
+            if (component.kind === 0 /* ComponentKind.Literal */) {
+                if (!this.equalAt(component.literal, text, start, end))
+                    return false;
+            }
+            else {
+                if (component.skipPackageFolders && isPackageFolder(text, start, end))
+                    return false;
+                if (!this.matchWildcard(component, text, start, end))
+                    return false;
+            }
+            offset = next;
+            index++;
+        }
+    }
+    /** Whether the components from `index` on can match nothing: only `**` remain. */
+    satisfiedFrom(index) {
+        for (let i = index; i < this.components.length; i++) {
+            if (this.components[i].kind !== 2 /* ComponentKind.DoubleAsterisk */)
+                return false;
+        }
+        return true;
+    }
+    matchWildcard(component, text, start, end) {
+        const segments = component.segments;
+        // Leading wildcards of includes don't match hidden names.
+        if (!this.isExclude && isHidden(text, start, end) && segments[0].kind !== 0 /* SegmentKind.Literal */)
+            return false;
+        if (segments.length === 2 && segments[0].kind === 1 /* SegmentKind.Star */ && segments[1].kind === 0 /* SegmentKind.Literal */) {
+            const literal = segments[1].literal;
+            if (end - start < literal.length || !this.equalAt(literal, text, end - literal.length, end))
+                return false;
+        }
+        else if (!this.matchSegments(segments, text, start, end)) {
+            return false;
+        }
+        return !this.excludeMinJs || component.mentionsMinSuffix || !this.hasMinJsSuffix(text, start, end);
+    }
+    /** Matches with backtracking to the last star only, in O(length × segments). */
+    matchSegments(segments, text, start, end) {
+        let index = 0;
+        let position = start;
+        let starIndex = -1;
+        let starPosition = start;
+        while (position < end) {
+            if (index < segments.length) {
+                const segment = segments[index];
+                if (segment.kind === 0 /* SegmentKind.Literal */) {
+                    const literalEnd = position + segment.literal.length;
+                    if (literalEnd <= end && this.equalAt(segment.literal, text, position, literalEnd)) {
+                        position = literalEnd;
+                        index++;
+                        continue;
+                    }
+                }
+                else if (segment.kind === 2 /* SegmentKind.Question */) {
+                    if (text.charCodeAt(position) !== 0x2f) {
+                        position += codePointLength(text, position);
+                        index++;
+                        continue;
+                    }
+                }
+                else {
+                    starIndex = index;
+                    starPosition = position;
+                    index++;
+                    continue;
+                }
+            }
+            if (starIndex >= 0 && starPosition < end && text.charCodeAt(starPosition) !== 0x2f) {
+                starPosition += codePointLength(text, starPosition);
+                position = starPosition;
+                index = starIndex + 1;
+                continue;
+            }
+            return false;
+        }
+        while (index < segments.length && segments[index].kind === 1 /* SegmentKind.Star */)
+            index++;
+        return index >= segments.length;
+    }
+    hasMinJsSuffix(text, start, end) {
+        if (end - start < 7)
+            return false;
+        return this.caseSensitive
+            ? text.startsWith('.min.js', end - 7)
+            : equalIgnoringCaseAt('.min.js', text, end - 7, end);
+    }
+    equalAt(literal, text, start, end) {
+        if (this.caseSensitive)
+            return end - start === literal.length && text.startsWith(literal, start);
+        return equalIgnoringCaseAt(literal, text, start, end);
+    }
+}
+function codePointLength(text, position) {
+    const ch = text.charCodeAt(position);
+    return ch >= 0xd800 && ch <= 0xdbff && position + 1 < text.length ? 2 : 1;
+}
+/** Whether `text.slice(start, end)` equals `literal` under case folding. */
+function equalIgnoringCaseAt(literal, text, start, end) {
+    if (end - start !== literal.length)
+        return equateStringsCaseInsensitive(literal, text.slice(start, end));
+    for (let i = 0; i < literal.length; i++) {
+        const a = literal.charCodeAt(i);
+        const b = text.charCodeAt(start + i);
+        if (a === b)
+            continue;
+        if (a >= 0x80 || b >= 0x80)
+            return equateStringsCaseInsensitive(literal, text.slice(start, end));
+        const lower = a | 0x20;
+        if (lower !== (b | 0x20) || lower < 0x61 || lower > 0x7a)
+            return false;
+    }
+    return true;
+}
+function isHidden(text, start, end) {
+    return end > start && text.charCodeAt(start) === 0x2e;
+}
+function isPackageFolder(text, start, end) {
+    switch (end - start) {
+        case 12:
+            return equalIgnoringCaseAt('node_modules', text, start, end);
+        case 13:
+            return equalIgnoringCaseAt('jspm_packages', text, start, end);
+        case 16:
+            return equalIgnoringCaseAt('bower_components', text, start, end);
+    }
+    return false;
+}
+// ---- Traversal
+/** Include and exclude patterns together. */
+class GlobMatcher {
+    includes = [];
+    excludes = [];
+    /** Include specs were given, even if none compiled. */
+    hadIncludes;
+    constructor(includeSpecs, excludeSpecs, basePath, caseSensitive, usage) {
+        this.hadIncludes = includeSpecs.length > 0;
+        for (const spec of includeSpecs) {
+            const pattern = GlobPattern.compile(spec, basePath, usage, caseSensitive);
+            if (pattern !== undefined)
+                this.includes.push(pattern);
+        }
+        for (const spec of excludeSpecs) {
+            const pattern = GlobPattern.compile(spec, basePath, 2 /* MatchUsage.Exclude */, caseSensitive);
+            if (pattern !== undefined)
+                this.excludes.push(pattern);
+        }
+    }
+    /** The index of the first include matching `directory + name`, or -1; 0 without includes. */
+    matchFile(directory, name) {
+        if (this.isExcluded(directory, name))
+            return -1;
+        if (this.includes.length === 0)
+            return this.hadIncludes ? -1 : 0;
+        for (let i = 0; i < this.includes.length; i++) {
+            if (this.includes[i].matches(directory, name, false))
+                return i;
+        }
+        return -1;
+    }
+    /** Whether files below `directory + name` could match. */
+    matchesDirectory(directory, name) {
+        if (this.isExcluded(directory, name))
+            return false;
+        if (this.includes.length === 0)
+            return !this.hadIncludes;
+        for (const include of this.includes)
+            if (include.matches(directory, name, true))
+                return true;
+        return false;
+    }
+    isExcluded(directory, name) {
+        for (const exclude of this.excludes)
+            if (exclude.matches(directory, name, false))
+                return true;
+        return false;
+    }
+}
+class GlobVisitor {
+    fs;
+    fileMatcher;
+    directoryMatcher;
+    extensions;
+    onMatch;
+    visited = new Set();
+    results;
+    constructor(fs, fileMatcher, directoryMatcher, extensions, 
+    /** Called with each file as it matches. */
+    onMatch) {
+        this.fs = fs;
+        this.fileMatcher = fileMatcher;
+        this.directoryMatcher = directoryMatcher;
+        this.extensions = extensions;
+        this.onMatch = onMatch;
+        const buckets = Math.max(fileMatcher.includes.length, 1);
+        this.results = [];
+        for (let i = 0; i < buckets; i++)
+            this.results.push([]);
+    }
+    /** Walks `absolutePath`; `realPath` is its known real path, or `''` to look it up. */
+    visit(path, absolutePath, depth, realPath) {
+        if (realPath === '')
+            realPath = this.fs.realpath(absolutePath);
+        const canonical = getCanonicalFileName(realPath, this.fs.useCaseSensitiveFileNames);
+        if (this.visited.has(canonical))
+            return;
+        this.visited.add(canonical);
+        const entries = this.fs.getAccessibleEntries(absolutePath);
+        const pathPrefix = withTrailingSlash(path);
+        const absolutePrefix = withTrailingSlash(absolutePath);
+        for (const file of entries.files) {
+            if (this.extensions.length > 0 && !fileExtensionIsOneOf(file, this.extensions))
+                continue;
+            const include = this.fileMatcher.matchFile(absolutePrefix, file);
+            if (include === -1)
+                continue;
+            const match = pathPrefix + file;
+            this.results[include].push(match);
+            if (this.onMatch !== undefined)
+                this.onMatch(match);
+        }
+        if (depth !== unlimitedDepth) {
+            depth--;
+            if (depth === 0)
+                return;
+        }
+        for (const directory of entries.directories) {
+            if (!this.directoryMatcher.matchesDirectory(absolutePrefix, directory))
+                continue;
+            // Real paths of plain subdirectories follow from the parent's; symlinks need a lookup.
+            const symlinks = entries.symlinks;
+            const childRealPath = symlinks !== undefined && !symlinks.has(directory) ? combinePaths(realPath, directory) : '';
+            this.visit(pathPrefix + directory, absolutePrefix + directory, depth, childRealPath);
+        }
+    }
+}
+function withTrailingSlash(path) {
+    return path.length > 0 && path.charCodeAt(path.length - 1) !== 0x2f ? path + '/' : path;
+}

package/dist/api/library/ast.d.ts

@@ -1,4 +1,4 @@
-import type { EndOfFile, EntityName, Identifier, KeywordSyntaxKind, ModifierSyntaxKind, PropertyAccessExpression, PunctuationSyntaxKind, Statement, ThisExpression, Token } from './ast.generated.js';
+import type { EndOfFile, EntityName, Identifier, KeywordSyntaxKind, ModifierSyntaxKind, NoSubstitutionTemplateLiteral, PropertyAccessExpression, PunctuationSyntaxKind, Statement, StringLiteral, ThisExpression, Token } from './ast.generated.js';
 import type { LanguageVariant, ModifierFlags, NodeFlags, ScriptKind, SyntaxKind } from './enums.generated.js';
 export interface TextRange {
     readonly pos: number;
@@ -12,7 +12,7 @@ export interface TextRange {
 export interface Node extends TextRange {
     readonly kind: SyntaxKind;
     readonly flags: NodeFlags;
-    readonly parent: Node;
+    readonly parent: Node | undefined;
 }
 /** The children of a node in one list: `nodes`, and the range from the list's opening to its closing token. */
 export interface NodeList<T extends Node = Node> extends TextRange {
@@ -66,6 +66,7 @@ export interface PropertyAccessEntityNameExpression extends PropertyAccessExpres
     readonly name: Identifier;
 }
 export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;
+export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
 export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;
 export interface JsxTagNamePropertyAccess extends PropertyAccessExpression {
     readonly expression: Identifier | ThisExpression | JsxTagNamePropertyAccess;