track-cli 3.0.0-rc

package/esm/deps/deno.land/std@0.195.0/fs/ensure_symlink.js

@@ -0,0 +1,68 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import * as path from "../path/mod.js";
+import { ensureDir, ensureDirSync } from "./ensure_dir.js";
+import { getFileInfoType, toPathString } from "./_util.js";
+import { isWindows } from "../_util/os.js";
+function resolveSymlinkTarget(target, linkName) {
+    if (typeof target != "string")
+        return target; // URL is always absolute path
+    if (typeof linkName == "string") {
+        return path.resolve(path.dirname(linkName), target);
+    }
+    else {
+        return new URL(target, linkName);
+    }
+}
+/**
+ * Ensures that the link exists, and points to a valid file.
+ * If the directory structure does not exist, it is created.
+ *
+ * @param target the source file path
+ * @param linkName the destination link path
+ */
+export async function ensureSymlink(target, linkName) {
+    const targetRealPath = resolveSymlinkTarget(target, linkName);
+    const srcStatInfo = await dntShim.Deno.lstat(targetRealPath);
+    const srcFilePathType = getFileInfoType(srcStatInfo);
+    await ensureDir(path.dirname(toPathString(linkName)));
+    const options = isWindows
+        ? {
+            type: srcFilePathType === "dir" ? "dir" : "file",
+        }
+        : undefined;
+    try {
+        await dntShim.Deno.symlink(target, linkName, options);
+    }
+    catch (error) {
+        if (!(error instanceof dntShim.Deno.errors.AlreadyExists)) {
+            throw error;
+        }
+    }
+}
+/**
+ * Ensures that the link exists, and points to a valid file.
+ * If the directory structure does not exist, it is created.
+ *
+ * @param target the source file path
+ * @param linkName the destination link path
+ */
+export function ensureSymlinkSync(target, linkName) {
+    const targetRealPath = resolveSymlinkTarget(target, linkName);
+    const srcStatInfo = dntShim.Deno.lstatSync(targetRealPath);
+    const srcFilePathType = getFileInfoType(srcStatInfo);
+    ensureDirSync(path.dirname(toPathString(linkName)));
+    const options = isWindows
+        ? {
+            type: srcFilePathType === "dir" ? "dir" : "file",
+        }
+        : undefined;
+    try {
+        dntShim.Deno.symlinkSync(target, linkName, options);
+    }
+    catch (error) {
+        if (!(error instanceof dntShim.Deno.errors.AlreadyExists)) {
+            throw error;
+        }
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/eol.d.ts

@@ -0,0 +1,40 @@
+/** Platform-specific conventions for the line ending format (i.e., the "end-of-line"). */
+export declare enum EOL {
+    /** Line Feed. Typically used in Unix (and Unix-like) systems. */
+    LF = "\n",
+    /** Carriage Return + Line Feed. Historically used in Windows and early DOS systems. */
+    CRLF = "\r\n"
+}
+/**
+ * Detect the EOL character for string input.
+ * returns null if no newline.
+ *
+ * @example
+ * ```ts
+ * import { detect, EOL } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * const CRLFinput = "deno\r\nis not\r\nnode";
+ * const Mixedinput = "deno\nis not\r\nnode";
+ * const LFinput = "deno\nis not\nnode";
+ * const NoNLinput = "deno is not node";
+ *
+ * detect(LFinput); // output EOL.LF
+ * detect(CRLFinput); // output EOL.CRLF
+ * detect(Mixedinput); // output EOL.CRLF
+ * detect(NoNLinput); // output null
+ * ```
+ */
+export declare function detect(content: string): EOL | null;
+/**
+ * Format the file to the targeted EOL.
+ *
+ * @example
+ * ```ts
+ * import { EOL, format } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * const CRLFinput = "deno\r\nis not\r\nnode";
+ *
+ * format(CRLFinput, EOL.LF); // output "deno\nis not\nnode"
+ * ```
+ */
+export declare function format(content: string, eol: EOL): string;

package/esm/deps/deno.land/std@0.195.0/fs/eol.js

@@ -0,0 +1,53 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// This module is browser compatible.
+/** Platform-specific conventions for the line ending format (i.e., the "end-of-line"). */
+export var EOL;
+(function (EOL) {
+    /** Line Feed. Typically used in Unix (and Unix-like) systems. */
+    EOL["LF"] = "\n";
+    /** Carriage Return + Line Feed. Historically used in Windows and early DOS systems. */
+    EOL["CRLF"] = "\r\n";
+})(EOL || (EOL = {}));
+const regDetect = /(?:\r?\n)/g;
+/**
+ * Detect the EOL character for string input.
+ * returns null if no newline.
+ *
+ * @example
+ * ```ts
+ * import { detect, EOL } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * const CRLFinput = "deno\r\nis not\r\nnode";
+ * const Mixedinput = "deno\nis not\r\nnode";
+ * const LFinput = "deno\nis not\nnode";
+ * const NoNLinput = "deno is not node";
+ *
+ * detect(LFinput); // output EOL.LF
+ * detect(CRLFinput); // output EOL.CRLF
+ * detect(Mixedinput); // output EOL.CRLF
+ * detect(NoNLinput); // output null
+ * ```
+ */
+export function detect(content) {
+    const d = content.match(regDetect);
+    if (!d || d.length === 0) {
+        return null;
+    }
+    const hasCRLF = d.some((x) => x === EOL.CRLF);
+    return hasCRLF ? EOL.CRLF : EOL.LF;
+}
+/**
+ * Format the file to the targeted EOL.
+ *
+ * @example
+ * ```ts
+ * import { EOL, format } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * const CRLFinput = "deno\r\nis not\r\nnode";
+ *
+ * format(CRLFinput, EOL.LF); // output "deno\nis not\nnode"
+ * ```
+ */
+export function format(content, eol) {
+    return content.replace(regDetect, eol);
+}

package/esm/deps/deno.land/std@0.195.0/fs/exists.d.ts

@@ -0,0 +1,102 @@
+/// <reference types="node" />
+export interface ExistsOptions {
+    /**
+     * When `true`, will check if the path is readable by the user as well.
+     * @default {false}
+     */
+    isReadable?: boolean;
+    /**
+     * When `true`, will check if the path is a directory as well.
+     * Directory symlinks are included.
+     * @default {false}
+     */
+    isDirectory?: boolean;
+    /**
+     * When `true`, will check if the path is a file as well.
+     * File symlinks are included.
+     * @default {false}
+     */
+    isFile?: boolean;
+}
+/**
+ * Test whether or not the given path exists by checking with the file system. Please consider to check if the path is readable and either a file or a directory by providing additional `options`:
+ *
+ * ```ts
+ * import { exists } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ * const isReadableDir = await exists("./foo", {
+ *   isReadable: true,
+ *   isDirectory: true
+ * });
+ * const isReadableFile = await exists("./bar", {
+ *   isReadable: true,
+ *   isFile: true
+ * });
+ * ```
+ *
+ * Note: Do not use this function if performing a check before another operation on that file. Doing so creates a race condition. Instead, perform the actual file operation directly.
+ *
+ * Bad:
+ * ```ts
+ * import { exists } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * if (await exists("./foo")) {
+ *   await Deno.remove("./foo");
+ * }
+ * ```
+ *
+ * Good:
+ * ```ts
+ * // Notice no use of exists
+ * try {
+ *   await Deno.remove("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use
+ */
+export declare function exists(path: string | URL, options?: ExistsOptions): Promise<boolean>;
+/**
+ * Test whether or not the given path exists by checking with the file system. Please consider to check if the path is readable and either a file or a directory by providing additional `options`:
+ *
+ * ```ts
+ * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ * const isReadableDir = existsSync("./foo", {
+ *   isReadable: true,
+ *   isDirectory: true
+ * });
+ * const isReadableFile = existsSync("./bar", {
+ *   isReadable: true,
+ *   isFile: true
+ * });
+ * ```
+ *
+ * Note: do not use this function if performing a check before another operation on that file. Doing so creates a race condition. Instead, perform the actual file operation directly.
+ *
+ * Bad:
+ * ```ts
+ * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * if (existsSync("./foo")) {
+ *   Deno.removeSync("./foo");
+ * }
+ * ```
+ *
+ * Good:
+ * ```ts
+ * // Notice no use of existsSync
+ * try {
+ *   Deno.removeSync("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use
+ */
+export declare function existsSync(path: string | URL, options?: ExistsOptions): boolean;

package/esm/deps/deno.land/std@0.195.0/fs/exists.js

@@ -0,0 +1,163 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+/**
+ * Test whether or not the given path exists by checking with the file system. Please consider to check if the path is readable and either a file or a directory by providing additional `options`:
+ *
+ * ```ts
+ * import { exists } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ * const isReadableDir = await exists("./foo", {
+ *   isReadable: true,
+ *   isDirectory: true
+ * });
+ * const isReadableFile = await exists("./bar", {
+ *   isReadable: true,
+ *   isFile: true
+ * });
+ * ```
+ *
+ * Note: Do not use this function if performing a check before another operation on that file. Doing so creates a race condition. Instead, perform the actual file operation directly.
+ *
+ * Bad:
+ * ```ts
+ * import { exists } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * if (await exists("./foo")) {
+ *   await Deno.remove("./foo");
+ * }
+ * ```
+ *
+ * Good:
+ * ```ts
+ * // Notice no use of exists
+ * try {
+ *   await Deno.remove("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use
+ */
+export async function exists(path, options) {
+    try {
+        const stat = await dntShim.Deno.stat(path);
+        if (options &&
+            (options.isReadable || options.isDirectory || options.isFile)) {
+            if (options.isDirectory && options.isFile) {
+                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together.");
+            }
+            if ((options.isDirectory && !stat.isDirectory) ||
+                (options.isFile && !stat.isFile)) {
+                return false;
+            }
+            if (options.isReadable) {
+                if (stat.mode == null) {
+                    return true; // Exclusive on Non-POSIX systems
+                }
+                if (dntShim.Deno.uid() == stat.uid) {
+                    return (stat.mode & 0o400) == 0o400; // User is owner and can read?
+                }
+                else if (dntShim.Deno.gid() == stat.gid) {
+                    return (stat.mode & 0o040) == 0o040; // User group is owner and can read?
+                }
+                return (stat.mode & 0o004) == 0o004; // Others can read?
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return false;
+        }
+        if (error instanceof dntShim.Deno.errors.PermissionDenied) {
+            if ((await dntShim.Deno.permissions.query({ name: "read", path })).state ===
+                "granted") {
+                // --allow-read not missing
+                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Test whether or not the given path exists by checking with the file system. Please consider to check if the path is readable and either a file or a directory by providing additional `options`:
+ *
+ * ```ts
+ * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ * const isReadableDir = existsSync("./foo", {
+ *   isReadable: true,
+ *   isDirectory: true
+ * });
+ * const isReadableFile = existsSync("./bar", {
+ *   isReadable: true,
+ *   isFile: true
+ * });
+ * ```
+ *
+ * Note: do not use this function if performing a check before another operation on that file. Doing so creates a race condition. Instead, perform the actual file operation directly.
+ *
+ * Bad:
+ * ```ts
+ * import { existsSync } from "https://deno.land/std@$STD_VERSION/fs/mod.ts";
+ *
+ * if (existsSync("./foo")) {
+ *   Deno.removeSync("./foo");
+ * }
+ * ```
+ *
+ * Good:
+ * ```ts
+ * // Notice no use of existsSync
+ * try {
+ *   Deno.removeSync("./foo", { recursive: true });
+ * } catch (error) {
+ *   if (!(error instanceof Deno.errors.NotFound)) {
+ *     throw error;
+ *   }
+ *   // Do nothing...
+ * }
+ * ```
+ * @see https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use
+ */
+export function existsSync(path, options) {
+    try {
+        const stat = dntShim.Deno.statSync(path);
+        if (options &&
+            (options.isReadable || options.isDirectory || options.isFile)) {
+            if (options.isDirectory && options.isFile) {
+                throw new TypeError("ExistsOptions.options.isDirectory and ExistsOptions.options.isFile must not be true together.");
+            }
+            if ((options.isDirectory && !stat.isDirectory) ||
+                (options.isFile && !stat.isFile)) {
+                return false;
+            }
+            if (options.isReadable) {
+                if (stat.mode == null) {
+                    return true; // Exclusive on Non-POSIX systems
+                }
+                if (dntShim.Deno.uid() == stat.uid) {
+                    return (stat.mode & 0o400) == 0o400; // User is owner and can read?
+                }
+                else if (dntShim.Deno.gid() == stat.gid) {
+                    return (stat.mode & 0o040) == 0o040; // User group is owner and can read?
+                }
+                return (stat.mode & 0o004) == 0o004; // Others can read?
+            }
+        }
+        return true;
+    }
+    catch (error) {
+        if (error instanceof dntShim.Deno.errors.NotFound) {
+            return false;
+        }
+        if (error instanceof dntShim.Deno.errors.PermissionDenied) {
+            if (dntShim.Deno.permissions.querySync({ name: "read", path }).state === "granted") {
+                // --allow-read not missing
+                return !options?.isReadable; // PermissionDenied was raised by file system, so the item exists, but can't be read
+            }
+        }
+        throw error;
+    }
+}

package/esm/deps/deno.land/std@0.195.0/fs/expand_glob.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { GlobOptions } from "../path/mod.js";
+import { WalkEntry } from "./_util.js";
+export interface ExpandGlobOptions extends Omit<GlobOptions, "os"> {
+    root?: string;
+    exclude?: string[];
+    includeDirs?: boolean;
+    followSymlinks?: boolean;
+}
+/**
+ * Expand the glob string from the specified `root` directory and yield each
+ * result as a `WalkEntry` object.
+ *
+ * See [`globToRegExp()`](../path/glob.ts#globToRegExp) for details on supported
+ * syntax.
+ *
+ * @example
+ * ```ts
+ * import { expandGlob } from "https://deno.land/std@$STD_VERSION/fs/expand_glob.ts";
+ * for await (const file of expandGlob("**\/*.ts")) {
+ *   console.log(file);
+ * }
+ * ```
+ */
+export declare function expandGlob(glob: string | URL, { root, exclude, includeDirs, extended, globstar, caseInsensitive, followSymlinks, }?: ExpandGlobOptions): AsyncIterableIterator<WalkEntry>;
+/**
+ * Synchronous version of `expandGlob()`.
+ *
+ * @example
+ * ```ts
+ * import { expandGlobSync } from "https://deno.land/std@$STD_VERSION/fs/expand_glob.ts";
+ * for (const file of expandGlobSync("**\/*.ts")) {
+ *   console.log(file);
+ * }
+ * ```
+ */
+export declare function expandGlobSync(glob: string | URL, { root, exclude, includeDirs, extended, globstar, caseInsensitive, followSymlinks, }?: ExpandGlobOptions): IterableIterator<WalkEntry>;

package/esm/deps/deno.land/std@0.195.0/fs/expand_glob.js

@@ -0,0 +1,216 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+import * as dntShim from "../../../../_dnt.shims.js";
+import { globToRegExp, isAbsolute, isGlob, joinGlobs, resolve, SEP_PATTERN, } from "../path/mod.js";
+import { walk, walkSync } from "./walk.js";
+import { assert } from "../assert/assert.js";
+import { isWindows } from "../_util/os.js";
+import { createWalkEntry, createWalkEntrySync, toPathString, } from "./_util.js";
+function split(path) {
+    const s = SEP_PATTERN.source;
+    const segments = path
+        .replace(new RegExp(`^${s}|${s}$`, "g"), "")
+        .split(SEP_PATTERN);
+    const isAbsolute_ = isAbsolute(path);
+    return {
+        segments,
+        isAbsolute: isAbsolute_,
+        hasTrailingSep: !!path.match(new RegExp(`${s}$`)),
+        winRoot: isWindows && isAbsolute_ ? segments.shift() : undefined,
+    };
+}
+function throwUnlessNotFound(error) {
+    if (!(error instanceof dntShim.Deno.errors.NotFound)) {
+        throw error;
+    }
+}
+function comparePath(a, b) {
+    if (a.path < b.path)
+        return -1;
+    if (a.path > b.path)
+        return 1;
+    return 0;
+}
+/**
+ * Expand the glob string from the specified `root` directory and yield each
+ * result as a `WalkEntry` object.
+ *
+ * See [`globToRegExp()`](../path/glob.ts#globToRegExp) for details on supported
+ * syntax.
+ *
+ * @example
+ * ```ts
+ * import { expandGlob } from "https://deno.land/std@$STD_VERSION/fs/expand_glob.ts";
+ * for await (const file of expandGlob("**\/*.ts")) {
+ *   console.log(file);
+ * }
+ * ```
+ */
+export async function* expandGlob(glob, { root = dntShim.Deno.cwd(), exclude = [], includeDirs = true, extended = true, globstar = true, caseInsensitive, followSymlinks, } = {}) {
+    const globOptions = { extended, globstar, caseInsensitive };
+    const absRoot = resolve(root);
+    const resolveFromRoot = (path) => resolve(absRoot, path);
+    const excludePatterns = exclude
+        .map(resolveFromRoot)
+        .map((s) => globToRegExp(s, globOptions));
+    const shouldInclude = (path) => !excludePatterns.some((p) => !!path.match(p));
+    const { segments, isAbsolute: isGlobAbsolute, hasTrailingSep, winRoot, } = split(toPathString(glob));
+    let fixedRoot = isGlobAbsolute
+        ? winRoot != undefined ? winRoot : "/"
+        : absRoot;
+    while (segments.length > 0 && !isGlob(segments[0])) {
+        const seg = segments.shift();
+        assert(seg != null);
+        fixedRoot = joinGlobs([fixedRoot, seg], globOptions);
+    }
+    let fixedRootInfo;
+    try {
+        fixedRootInfo = await createWalkEntry(fixedRoot);
+    }
+    catch (error) {
+        return throwUnlessNotFound(error);
+    }
+    async function* advanceMatch(walkInfo, globSegment) {
+        if (!walkInfo.isDirectory) {
+            return;
+        }
+        else if (globSegment == "..") {
+            const parentPath = joinGlobs([walkInfo.path, ".."], globOptions);
+            try {
+                if (shouldInclude(parentPath)) {
+                    return yield await createWalkEntry(parentPath);
+                }
+            }
+            catch (error) {
+                throwUnlessNotFound(error);
+            }
+            return;
+        }
+        else if (globSegment == "**") {
+            return yield* walk(walkInfo.path, {
+                skip: excludePatterns,
+                maxDepth: globstar ? Infinity : 1,
+                followSymlinks,
+            });
+        }
+        const globPattern = globToRegExp(globSegment, globOptions);
+        for await (const walkEntry of walk(walkInfo.path, {
+            maxDepth: 1,
+            skip: excludePatterns,
+            followSymlinks,
+        })) {
+            if (walkEntry.path != walkInfo.path &&
+                walkEntry.name.match(globPattern)) {
+                yield walkEntry;
+            }
+        }
+    }
+    let currentMatches = [fixedRootInfo];
+    for (const segment of segments) {
+        // Advancing the list of current matches may introduce duplicates, so we
+        // pass everything through this Map.
+        const nextMatchMap = new Map();
+        await Promise.all(currentMatches.map(async (currentMatch) => {
+            for await (const nextMatch of advanceMatch(currentMatch, segment)) {
+                nextMatchMap.set(nextMatch.path, nextMatch);
+            }
+        }));
+        currentMatches = [...nextMatchMap.values()].sort(comparePath);
+    }
+    if (hasTrailingSep) {
+        currentMatches = currentMatches.filter((entry) => entry.isDirectory);
+    }
+    if (!includeDirs) {
+        currentMatches = currentMatches.filter((entry) => !entry.isDirectory);
+    }
+    yield* currentMatches;
+}
+/**
+ * Synchronous version of `expandGlob()`.
+ *
+ * @example
+ * ```ts
+ * import { expandGlobSync } from "https://deno.land/std@$STD_VERSION/fs/expand_glob.ts";
+ * for (const file of expandGlobSync("**\/*.ts")) {
+ *   console.log(file);
+ * }
+ * ```
+ */
+export function* expandGlobSync(glob, { root = dntShim.Deno.cwd(), exclude = [], includeDirs = true, extended = true, globstar = true, caseInsensitive, followSymlinks, } = {}) {
+    const globOptions = { extended, globstar, caseInsensitive };
+    const absRoot = resolve(root);
+    const resolveFromRoot = (path) => resolve(absRoot, path);
+    const excludePatterns = exclude
+        .map(resolveFromRoot)
+        .map((s) => globToRegExp(s, globOptions));
+    const shouldInclude = (path) => !excludePatterns.some((p) => !!path.match(p));
+    const { segments, isAbsolute: isGlobAbsolute, hasTrailingSep, winRoot, } = split(toPathString(glob));
+    let fixedRoot = isGlobAbsolute
+        ? winRoot != undefined ? winRoot : "/"
+        : absRoot;
+    while (segments.length > 0 && !isGlob(segments[0])) {
+        const seg = segments.shift();
+        assert(seg != null);
+        fixedRoot = joinGlobs([fixedRoot, seg], globOptions);
+    }
+    let fixedRootInfo;
+    try {
+        fixedRootInfo = createWalkEntrySync(fixedRoot);
+    }
+    catch (error) {
+        return throwUnlessNotFound(error);
+    }
+    function* advanceMatch(walkInfo, globSegment) {
+        if (!walkInfo.isDirectory) {
+            return;
+        }
+        else if (globSegment == "..") {
+            const parentPath = joinGlobs([walkInfo.path, ".."], globOptions);
+            try {
+                if (shouldInclude(parentPath)) {
+                    return yield createWalkEntrySync(parentPath);
+                }
+            }
+            catch (error) {
+                throwUnlessNotFound(error);
+            }
+            return;
+        }
+        else if (globSegment == "**") {
+            return yield* walkSync(walkInfo.path, {
+                skip: excludePatterns,
+                maxDepth: globstar ? Infinity : 1,
+                followSymlinks,
+            });
+        }
+        const globPattern = globToRegExp(globSegment, globOptions);
+        for (const walkEntry of walkSync(walkInfo.path, {
+            maxDepth: 1,
+            skip: excludePatterns,
+            followSymlinks,
+        })) {
+            if (walkEntry.path != walkInfo.path &&
+                walkEntry.name.match(globPattern)) {
+                yield walkEntry;
+            }
+        }
+    }
+    let currentMatches = [fixedRootInfo];
+    for (const segment of segments) {
+        // Advancing the list of current matches may introduce duplicates, so we
+        // pass everything through this Map.
+        const nextMatchMap = new Map();
+        for (const currentMatch of currentMatches) {
+            for (const nextMatch of advanceMatch(currentMatch, segment)) {
+                nextMatchMap.set(nextMatch.path, nextMatch);
+            }
+        }
+        currentMatches = [...nextMatchMap.values()].sort(comparePath);
+    }
+    if (hasTrailingSep) {
+        currentMatches = currentMatches.filter((entry) => entry.isDirectory);
+    }
+    if (!includeDirs) {
+        currentMatches = currentMatches.filter((entry) => !entry.isDirectory);
+    }
+    yield* currentMatches;
+}