cspell-glob 8.9.0 → 8.10.0

package/dist/{esm/GlobMatcher.d.ts → GlobMatcher.d.ts}

@@ -65,22 +65,29 @@ export declare class GlobMatcher {
     readonly path: PathInterface;
     readonly patterns: GlobPatternWithRoot[];
     readonly patternsNormalizedToRoot: GlobPatternNormalized[];
+    /**
+     * path or href of the root directory.
+     */
     readonly root: string;
     readonly dot: boolean;
     readonly options: NormalizedGlobMatchOptions;
+    /**
+     * Instance ID
+     */
+    readonly id: number;
     /**
      * Construct a `.gitignore` emulator
      * @param patterns - the contents of a `.gitignore` style file or an array of individual glob rules.
      * @param root - the working directory
      */
-    constructor(patterns: GlobPattern | GlobPattern[], root?: string, nodePath?: PathInterface);
+    constructor(patterns: GlobPattern | GlobPattern[], root?: string | URL, nodePath?: PathInterface);
     /**
      * Construct a `.gitignore` emulator
      * @param patterns - the contents of a `.gitignore` style file or an array of individual glob rules.
      * @param options - to set the root and other options
      */
     constructor(patterns: GlobPattern | GlobPattern[], options?: GlobMatchOptions);
-    constructor(patterns: GlobPattern | GlobPattern[], rootOrOptions?: string | GlobMatchOptions);
+    constructor(patterns: GlobPattern | GlobPattern[], rootOrOptions?: string | URL | GlobMatchOptions);
     /**
      * Check to see if a filename matches any of the globs.
      * If filename is relative, it is considered relative to the root.

package/dist/{esm/GlobMatcher.js → GlobMatcher.js}

@@ -1,6 +1,9 @@
 import * as Path from 'node:path';
+import { FileUrlBuilder } from '@cspell/url';
 import mm from 'micromatch';
-import { doesRootContainPath, normalizeGlobPatterns, normalizeGlobToRoot } from './globHelper.js';
+import { GlobPatterns, isRelativeValueNested, normalizeGlobPatterns, normalizeGlobToRoot } from './globHelper.js';
+const traceMode = false;
+let idGlobMatcher = 0;
 export class GlobMatcher {
     /**
      * @param filename full path of file to match against.
@@ -10,17 +13,34 @@ export class GlobMatcher {
     path;
     patterns;
     patternsNormalizedToRoot;
+    /**
+     * path or href of the root directory.
+     */
     root;
     dot;
     options;
+    /**
+     * Instance ID
+     */
+    id;
     constructor(patterns, rootOrOptions, _nodePath) {
-        _nodePath = _nodePath ?? Path;
-        const options = typeof rootOrOptions === 'string' ? { root: rootOrOptions } : rootOrOptions ?? {};
-        const { mode = 'exclude' } = options;
+        this.id = idGlobMatcher++;
+        // traceMode && console.warn('GlobMatcher(%d)', this.id, new Error('trace'));
+        const options = typeof rootOrOptions === 'string' || rootOrOptions instanceof URL
+            ? { root: rootOrOptions.toString() }
+            : rootOrOptions ?? {};
+        const mode = options.mode ?? 'exclude';
         const isExcludeMode = mode !== 'include';
-        _nodePath = options.nodePath ?? _nodePath;
-        const { root = _nodePath.resolve(), dot = isExcludeMode, nodePath = _nodePath, nested = isExcludeMode, cwd = process.cwd(), nobrace, } = options;
-        const normalizedRoot = nodePath.resolve(nodePath.normalize(root));
+        const nodePath = options.nodePath ?? _nodePath ?? Path;
+        this.path = nodePath;
+        const cwd = options.cwd ?? nodePath.resolve();
+        const dot = options.dot ?? isExcludeMode;
+        const nested = options.nested ?? isExcludeMode;
+        const nobrace = options.nobrace;
+        const root = options.root ?? nodePath.resolve();
+        const builder = new FileUrlBuilder({ path: nodePath });
+        const rootURL = builder.toFileDirURL(root);
+        const normalizedRoot = builder.urlToFilePathOrHref(rootURL);
         this.options = { root: normalizedRoot, dot, nodePath, nested, mode, nobrace, cwd };
         patterns = Array.isArray(patterns)
             ? patterns
@@ -31,12 +51,11 @@ export class GlobMatcher {
         this.patternsNormalizedToRoot = globPatterns
             .map((g) => normalizeGlobToRoot(g, normalizedRoot, nodePath))
             // Only keep globs that do not match the root when using exclude mode.
-            .filter((g) => nodePath.relative(g.root, normalizedRoot) === '');
+            .filter((g) => builder.relative(builder.toFileDirURL(g.root), rootURL) === '');
         this.patterns = globPatterns;
         this.root = normalizedRoot;
-        this.path = nodePath;
         this.dot = dot;
-        this.matchEx = buildMatcherFn(this.patterns, this.options);
+        this.matchEx = buildMatcherFn(this.id, this.patterns, this.options);
     }
     /**
      * Check to see if a filename matches any of the globs.
@@ -62,9 +81,12 @@ export class GlobMatcher {
  * @param options - defines root and other options
  * @returns a function given a filename returns true if it matches.
  */
-function buildMatcherFn(patterns, options) {
-    const { nodePath: path, dot, nobrace } = options;
+function buildMatcherFn(_id, patterns, options) {
+    // outputBuildMatcherFnPerfData(_id, patterns, options);
+    const { nodePath, dot, nobrace } = options;
+    const builder = new FileUrlBuilder({ path: nodePath });
     const makeReOptions = { dot, nobrace };
+    const suffixDir = GlobPatterns.suffixDir;
     const rules = patterns
         .map((pattern, index) => ({ pattern, index }))
         .filter((r) => !!r.pattern.glob)
@@ -74,29 +96,43 @@ function buildMatcherFn(patterns, options) {
         const glob = pattern.glob.replace(/^!/, '');
         const isNeg = (matchNeg && matchNeg[0].length & 1 && true) || false;
         const reg = mm.makeRe(glob, makeReOptions);
-        const fn = (filename) => {
-            reg.lastIndex = 0;
-            return reg.test(filename);
-        };
+        const fn = pattern.glob.endsWith(suffixDir)
+            ? (filename) => {
+                // Note: this is a hack to get around the limitations of globs.
+                // We want to match a filename with a trailing slash, but micromatch does not support it.
+                // So it is necessary to pretend that the filename has a space at the end.
+                return reg.test(filename) || (filename.endsWith('/') && reg.test(filename + ' '));
+            }
+            : (filename) => {
+                return reg.test(filename);
+            };
         return { pattern, index, isNeg, fn, reg };
     });
     const negRules = rules.filter((r) => r.isNeg);
     const posRules = rules.filter((r) => !r.isNeg);
+    const mapRoots = new Map();
     // const negRegEx = negRules.map((r) => r.reg).map((r) => r.toString());
     // const posRegEx = posRules.map((r) => r.reg).map((r) => r.toString());
     // console.error('buildMatcherFn %o', { negRegEx, posRegEx, stack: new Error().stack });
     // const negReg = joinRegExp(negRegEx);
     // const posReg = joinRegExp(posRegEx);
     const fn = (filename) => {
-        filename = path.resolve(path.normalize(filename));
-        const fNameNormalize = path.sep === '\\' ? filename.replaceAll('\\', '/') : filename;
-        let lastRoot = '!!!!!!';
+        const fileUrl = builder.toFileURL(filename);
+        const relFilePathname = builder.relative(new URL('file:///'), fileUrl);
+        let lastRoot = new URL('placeHolder://');
         let lastRel = '';
+        function rootToUrl(root) {
+            const found = mapRoots.get(root);
+            if (found)
+                return found;
+            const url = builder.toFileDirURL(root);
+            mapRoots.set(root, url);
+            return url;
+        }
         function relativeToRoot(root) {
-            if (root !== lastRoot) {
+            if (root.href !== lastRoot.href) {
                 lastRoot = root;
-                const relName = path.relative(root, filename);
-                lastRel = path.sep === '\\' ? relName.replaceAll('\\', '/') : relName;
+                lastRel = builder.relative(root, fileUrl);
             }
             return lastRel;
         }
@@ -104,11 +140,16 @@ function buildMatcherFn(patterns, options) {
             for (const rule of rules) {
                 const pattern = rule.pattern;
                 const root = pattern.root;
+                const rootURL = rootToUrl(root);
                 const isRelPat = !pattern.isGlobalPattern;
-                if (isRelPat && !doesRootContainPath(root, filename, path)) {
-                    continue;
+                let fname = relFilePathname;
+                if (isRelPat) {
+                    const relPathToFile = relativeToRoot(rootURL);
+                    if (!isRelativeValueNested(relPathToFile)) {
+                        continue;
+                    }
+                    fname = relPathToFile;
                 }
-                const fname = isRelPat ? relativeToRoot(root) : fNameNormalize;
                 if (rule.fn(fname)) {
                     return {
                         matched,
@@ -121,15 +162,29 @@ function buildMatcherFn(patterns, options) {
                 }
             }
         }
-        return testRules(negRules, false) || testRules(posRules, true) || { matched: false };
+        const result = testRules(negRules, false) || testRules(posRules, true) || { matched: false };
+        traceMode && logMatchTest(_id, filename, result);
+        return result;
     };
     return fn;
 }
-// function _joinRegExp(patterns: RegExp[]): RegExp | undefined {
-//     if (!patterns.length) {
-//         return undefined;
-//     }
-//     const joined = patterns.map((p) => `(?:${p.source})`).join('|');
-//     return new RegExp(joined);
+function logMatchTest(id, filename, match) {
+    console.warn('%s;%d;%s', filename, id, JSON.stringify(match.matched));
+}
+// function outputBuildMatcherFnPerfData(patterns: GlobPatternWithRoot[], options: NormalizedGlobMatchOptions) {
+//     console.warn(
+//         JSON.stringify({
+//             options: {
+//                 ...options,
+//                 nodePath: undefined,
+//                 root: Path.relative(process.cwd(), options.root),
+//                 cwd: Path.relative(process.cwd(), options.cwd),
+//             },
+//             patterns: patterns.map(({ glob, root, isGlobalPattern }) => ({
+//                 glob,
+//                 root: isGlobalPattern ? undefined : Path.relative(process.cwd(), root),
+//             })),
+//         }) + ',',
+//     );
 // }
 //# sourceMappingURL=GlobMatcher.js.map

package/dist/{esm/GlobMatcherTypes.d.ts → GlobMatcherTypes.d.ts}

@@ -4,6 +4,13 @@ export interface PathInterface {
     resolve(...paths: string[]): string;
     relative(from: string, to: string): string;
     isAbsolute(p: string): boolean;
+    parse(p: string): {
+        root: string;
+        dir: string;
+        base: string;
+        ext: string;
+        name: string;
+    };
     sep: string;
 }
 export type GlobMatch = GlobMatchRule | GlobMatchNoRule;
@@ -43,6 +50,7 @@ export interface GlobPatternWithRoot extends GlobPatternWithOptionalRoot {
     root: string;
     /**
      * Global patterns do not need to be relative to the root.
+     * Note: Some patterns start with `**` but they are tied to the root. In this case, `isGlobalPattern` is `false`.
      */
     isGlobalPattern: boolean;
 }

package/dist/{esm/globHelper.d.ts → globHelper.d.ts}

@@ -1,4 +1,15 @@
 import type { GlobPattern, GlobPatternNormalized, GlobPatternWithOptionalRoot, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes.js';
+export declare const GlobPlaceHolders: {
+    cwd: string;
+};
+export declare const GlobPatterns: {
+    suffixAny: string;
+    /**
+     * Use as as suffix for a directory. Example `node_modules/` becomes `node_modules/**​/*`.
+     */
+    suffixDir: string;
+    prefixAny: string;
+};
 /**
  * This function tries its best to determine if `fileOrGlob` is a path to a file or a glob pattern.
  * @param fileOrGlob - file (with absolute path) or glob.
@@ -6,15 +17,10 @@ import type { GlobPattern, GlobPatternNormalized, GlobPatternWithOptionalRoot, G
  * @param path - optional node path methods - used for testing
  */
 export declare function fileOrGlobToGlob(fileOrGlob: string | GlobPattern, root: string, path?: PathInterface): GlobPatternWithRoot;
-/**
- * Decide if a childPath is contained within a root or at the same level.
- * @param root - absolute path
- * @param childPath - absolute path
- */
-export declare function doesRootContainPath(root: string, child: string, path: PathInterface): boolean;
 export declare function isGlobPatternWithOptionalRoot(g: GlobPattern): g is GlobPatternWithOptionalRoot;
-export declare function isGlobPatternWithRoot(g: GlobPatternWithRoot | GlobPatternWithOptionalRoot): g is GlobPatternWithRoot;
+export declare function isGlobPatternWithRoot(g: GlobPattern): g is GlobPatternWithRoot;
 export declare function isGlobPatternNormalized(g: GlobPattern | GlobPatternNormalized): g is GlobPatternNormalized;
+export declare function isGlobPatternNormalizedToRoot(g: GlobPattern | GlobPatternNormalized, options: NormalizeOptions): g is GlobPatternNormalized;
 export interface NormalizeOptions {
     /**
      * Indicates that the glob should be modified to match nested patterns.
@@ -51,18 +57,24 @@ export declare function normalizeGlobPattern(g: GlobPattern, options: NormalizeO
  * @param path - Node Path modules to use (testing only)
  */
 export declare function normalizeGlobToRoot<Glob extends GlobPatternWithRoot>(glob: Glob, root: string, path: PathInterface): Glob;
+export declare function isRelativeValueNested(rel: string): boolean;
 /**
  * Rebase a glob string to a new prefix
  * @param glob - glob string
  * @param rebaseTo - glob prefix
  */
-declare function rebaseGlob(glob: string, rebaseTo: string): string | undefined;
+export declare function rebaseGlob(glob: string, rebaseTo: string): string | undefined;
 /**
  * Trims any trailing spaces, tabs, line-feeds, new-lines, and comments
  * @param glob - glob string
  * @returns trimmed glob
  */
-declare function trimGlob(glob: string): string;
+export declare function trimGlob(glob: string): string;
+/**
+ * Test if a glob pattern has a leading `**`.
+ * @param glob - the glob
+ * @returns true if the glob pattern starts with `**`
+ */
 declare function isGlobalGlob(glob: string): boolean;
 export declare const __testing__: {
     rebaseGlob: typeof rebaseGlob;

package/dist/globHelper.js

@@ -0,0 +1,430 @@
+/* eslint-disable no-irregular-whitespace */
+import * as Path from 'node:path';
+import { FileUrlBuilder } from '@cspell/url';
+const { posix } = Path;
+// const relRegExp = /^\..?[\\/]/;
+/** test for glob patterns starting with `**` */
+const isGlobalPatternRegExp = /^!*[*]{2}/;
+const hasGlobCharactersRegExp = /[*?{}[\]]/;
+const fileUrlBuilder = new FileUrlBuilder();
+export const GlobPlaceHolders = {
+    cwd: '${cwd}',
+};
+export const GlobPatterns = {
+    suffixAny: '/**',
+    /**
+     * Use as as suffix for a directory. Example `node_modules/` becomes `node_modules/**​/*`.
+     */
+    suffixDir: '/**/*',
+    prefixAny: '**/',
+};
+let cacheCalls = 0;
+let cacheMisses = 0;
+let cachePath = Path;
+let cacheRoot = '<>';
+const cache = new Map();
+const debugCache = false;
+/**
+ * This function tries its best to determine if `fileOrGlob` is a path to a file or a glob pattern.
+ * @param fileOrGlob - file (with absolute path) or glob.
+ * @param root - absolute path to the directory that will be considered the root when testing the glob pattern.
+ * @param path - optional node path methods - used for testing
+ */
+export function fileOrGlobToGlob(fileOrGlob, root, path = Path) {
+    if (cacheRoot !== root || cachePath !== path) {
+        cache.clear();
+        cacheCalls = 0;
+        cacheMisses = 0;
+        cacheRoot = root;
+        cachePath = path;
+    }
+    ++cacheCalls;
+    debugCache &&
+        !(cacheCalls & 0x7) &&
+        console.error('cache miss rate: %d%% cache size: %d', (cacheMisses / cacheCalls) * 100, cache.size);
+    const found = cache.get(fileOrGlob);
+    if (found)
+        return found;
+    ++cacheMisses;
+    const pattern = _fileOrGlobToGlob(fileOrGlob, root, path);
+    cache.set(fileOrGlob, pattern);
+    return pattern;
+}
+/**
+ * This function tries its best to determine if `fileOrGlob` is a path to a file or a glob pattern.
+ * @param fileOrGlob - file (with absolute path) or glob.
+ * @param root - absolute path to the directory that will be considered the root when testing the glob pattern.
+ * @param path - optional node path methods - used for testing
+ */
+function _fileOrGlobToGlob(fileOrGlob, root, path = Path) {
+    const toForwardSlash = path.sep === '\\' ? (p) => p.replaceAll('\\', '/') : (p) => p;
+    const builder = urlBuilder(path);
+    fileOrGlob = typeof fileOrGlob === 'string' ? toForwardSlash(fileOrGlob) : fileOrGlob;
+    const rootUrl = builder.toFileDirURL(root);
+    // Normalize root
+    root = builder.urlToFilePathOrHref(rootUrl);
+    const pattern = toGlobPatternWithRoot(fileOrGlob, root, builder);
+    // if (root.includes(GlobPlaceHolders.cwd) || pattern.root.includes(GlobPlaceHolders.cwd)) {
+    //     console.warn('fileOrGlobToGlob: root or pattern contains ${cwd}', { root, pattern, fileOrGlob });
+    // }
+    return pattern;
+}
+function toGlobPatternWithRoot(glob, root, builder) {
+    function toPattern() {
+        if (isGlobPatternWithRoot(glob))
+            return fixPatternRoot({ ...glob }, builder);
+        const rootUrl = builder.toFileDirURL(root);
+        if (typeof glob === 'string')
+            return filePathOrGlobToGlob(glob, rootUrl, builder);
+        const pattern = { isGlobalPattern: isGlobalGlob(glob.glob), ...glob, root: glob.root ?? root };
+        fixPatternRoot(pattern, builder);
+        // pattern.glob might still be a file or a relative glob pattern.
+        fixPatternGlob(pattern, builder);
+        return pattern;
+    }
+    const pattern = toPattern();
+    if (pattern.glob.startsWith(GlobPlaceHolders.cwd)) {
+        pattern.root = GlobPlaceHolders.cwd;
+        pattern.glob = pattern.glob.replace(GlobPlaceHolders.cwd, '');
+    }
+    return pattern;
+}
+export function isGlobPatternWithOptionalRoot(g) {
+    return typeof g !== 'string' && typeof g.glob === 'string';
+}
+export function isGlobPatternWithRoot(g) {
+    if (typeof g === 'string')
+        return false;
+    return typeof g.root === 'string' && 'isGlobalPattern' in g;
+}
+export function isGlobPatternNormalized(g) {
+    if (!isGlobPatternWithRoot(g))
+        return false;
+    const gr = g;
+    return 'rawGlob' in gr && 'rawRoot' in gr && typeof gr.rawGlob === 'string';
+}
+export function isGlobPatternNormalizedToRoot(g, options) {
+    if (!isGlobPatternNormalized(g))
+        return false;
+    return g.root === options.root;
+}
+function urlBuilder(path = Path) {
+    return path === Path ? fileUrlBuilder : new FileUrlBuilder({ path });
+}
+/**
+ * @param pattern glob pattern
+ * @param nested when true add `**​/<glob>/​**`
+ * @returns the set of matching globs.
+ */
+function normalizePattern(pattern, nested) {
+    pattern = pattern.replace(/^(!!)+/, '');
+    const isNeg = pattern.startsWith('!');
+    const prefix = isNeg ? '!' : '';
+    pattern = isNeg ? pattern.slice(1) : pattern;
+    const patterns = nested ? normalizePatternNested(pattern) : normalizePatternGeneral(pattern);
+    return patterns.map((p) => prefix + p);
+}
+function normalizePatternNested(pattern) {
+    // no slashes will match files names or folders
+    if (!pattern.includes('/')) {
+        if (pattern === '**')
+            return ['**'];
+        return ['**/' + pattern, '**/' + pattern + '/**'];
+    }
+    const hasLeadingSlash = pattern.startsWith('/');
+    pattern = hasLeadingSlash ? pattern.slice(1) : pattern;
+    if (pattern.endsWith('/')) {
+        // See: https://git-scm.com/docs/gitignore#_pattern_format
+        // if it only has a trailing slash, allow matching against a nested directory.
+        return hasLeadingSlash || pattern.slice(0, -1).includes('/') ? [pattern + '**/*'] : ['**/' + pattern + '**/*'];
+    }
+    if (pattern.endsWith('**')) {
+        return [pattern];
+    }
+    return [pattern, pattern + '/**'];
+}
+function normalizePatternGeneral(pattern) {
+    pattern = pattern.startsWith('/') ? pattern.slice(1) : pattern;
+    pattern = pattern.endsWith('/') ? pattern + '**/*' : pattern;
+    return [pattern];
+}
+/**
+ *
+ * @param patterns - glob patterns to normalize.
+ * @param options - Normalization options.
+ */
+export function normalizeGlobPatterns(patterns, options) {
+    function* normalize() {
+        for (const glob of patterns) {
+            if (isGlobPatternNormalized(glob)) {
+                yield isGlobPatternNormalizedToRoot(glob, options)
+                    ? glob
+                    : normalizeGlobToRoot(glob, options.root, options.nodePath || Path);
+                continue;
+            }
+            yield* normalizeGlobPattern(glob, options);
+        }
+    }
+    return [...normalize()];
+}
+export function normalizeGlobPattern(g, options) {
+    const { root, nodePath: path = Path, nested } = options;
+    const builder = urlBuilder(path);
+    const cwd = options.cwd ?? path.resolve();
+    const cwdUrl = builder.toFileDirURL(cwd);
+    const rootUrl = builder.toFileDirURL(root, cwdUrl);
+    const gIsGlobalPattern = isGlobPatternWithRoot(g) ? g.isGlobalPattern : undefined;
+    g = !isGlobPatternWithOptionalRoot(g) ? { glob: g } : g;
+    const gr = { ...g, root: g.root ?? root };
+    const rawRoot = gr.root;
+    const rawGlob = g.glob;
+    gr.glob = trimGlob(g.glob);
+    if (gr.glob.startsWith(GlobPlaceHolders.cwd)) {
+        gr.glob = gr.glob.replace(GlobPlaceHolders.cwd, '');
+        gr.root = GlobPlaceHolders.cwd;
+    }
+    if (gr.root.startsWith(GlobPlaceHolders.cwd)) {
+        const relRoot = gr.root.replace(GlobPlaceHolders.cwd, './');
+        const r = builder.toFileDirURL(relRoot, cwdUrl);
+        r.pathname = posix.normalize(r.pathname);
+        gr.root = builder.urlToFilePathOrHref(r);
+    }
+    const isGlobalPattern = gIsGlobalPattern ?? isGlobalGlob(gr.glob);
+    gr.root = builder.urlToFilePathOrHref(builder.toFileDirURL(gr.root, rootUrl));
+    const globs = normalizePattern(gr.glob, nested);
+    return globs.map((glob) => ({ ...gr, glob, rawGlob, rawRoot, isGlobalPattern }));
+}
+/**
+ * Try to adjust the root of a glob to match a new root. If it is not possible, the original glob is returned.
+ * Note: this does NOT generate absolutely correct glob patterns. The results are intended to be used as a
+ * first pass only filter. Followed by testing against the original glob/root pair.
+ * @param glob - glob to map
+ * @param root - new root to use if possible
+ * @param path - Node Path modules to use (testing only)
+ */
+export function normalizeGlobToRoot(glob, root, path) {
+    const builder = urlBuilder(path);
+    glob = { ...glob };
+    fixPatternRoot(glob, builder);
+    const rootURL = builder.toFileDirURL(root);
+    root = builder.urlToFilePathOrHref(rootURL);
+    if (glob.root === root) {
+        return glob;
+    }
+    const globRootUrl = builder.toFileDirURL(glob.root);
+    const relFromRootToGlob = builder.relative(rootURL, globRootUrl);
+    if (!relFromRootToGlob) {
+        return glob;
+    }
+    if (glob.isGlobalPattern) {
+        return { ...glob, root };
+    }
+    const relFromGlobToRoot = builder.relative(globRootUrl, rootURL);
+    const globIsUnderRoot = isRelativeValueNested(relFromRootToGlob);
+    const rootIsUnderGlob = isRelativeValueNested(relFromGlobToRoot);
+    // Root and Glob are not in the same part of the directory tree.
+    if (!globIsUnderRoot && !rootIsUnderGlob) {
+        return glob;
+    }
+    const isNeg = glob.glob.startsWith('!');
+    const g = isNeg ? glob.glob.slice(1) : glob.glob;
+    const prefix = isNeg ? '!' : '';
+    // prefix with root
+    if (globIsUnderRoot) {
+        const relGlob = relFromRootToGlob;
+        return {
+            ...glob,
+            glob: prefix + posix.join(relGlob, g),
+            root,
+        };
+    }
+    // The root is under the glob root
+    // The more difficult case, the glob is higher than the root
+    // A best effort is made, but does not do advanced matching.
+    const relGlob = (relFromGlobToRoot + '/').replaceAll('//', '/');
+    const rebasedGlob = rebaseGlob(g, relGlob);
+    return rebasedGlob ? { ...glob, glob: prefix + rebasedGlob, root } : glob;
+}
+export function isRelativeValueNested(rel) {
+    return !rel || !(rel === '..' || rel.startsWith('../') || rel.startsWith('/'));
+}
+/**
+ * Rebase a glob string to a new prefix
+ * @param glob - glob string
+ * @param rebaseTo - glob prefix
+ */
+export function rebaseGlob(glob, rebaseTo) {
+    if (!rebaseTo || rebaseTo === '/')
+        return glob;
+    if (glob.startsWith('**'))
+        return glob;
+    rebaseTo = rebaseTo.endsWith('/') ? rebaseTo : rebaseTo + '/';
+    if (glob.startsWith(rebaseTo)) {
+        return glob.slice(rebaseTo.length);
+    }
+    const relParts = rebaseTo.split('/');
+    const globParts = glob.split('/');
+    for (let i = 0; i < relParts.length && i < globParts.length; ++i) {
+        const relSeg = relParts[i];
+        const globSeg = globParts[i];
+        // the empty segment due to the end relGlob / allows for us to test against an empty segment.
+        if (!relSeg || globSeg === '**') {
+            return globParts.slice(i).join('/');
+        }
+        if (relSeg !== globSeg && globSeg !== '*') {
+            break;
+        }
+    }
+    return undefined;
+}
+/**
+ * Trims any trailing spaces, tabs, line-feeds, new-lines, and comments
+ * @param glob - glob string
+ * @returns trimmed glob
+ */
+export function trimGlob(glob) {
+    glob = globRemoveComment(glob);
+    glob = trimGlobLeft(glob);
+    glob = trimGlobRight(glob);
+    return glob;
+}
+function globRemoveComment(glob) {
+    return glob.replace(/(?<=^|\s)#.*/, '');
+}
+const spaces = {
+    ' ': true,
+    '\t': true,
+    '\n': true,
+    '\r': true,
+};
+/**
+ * Trim any trailing spaces, tabs, line-feeds, or new-lines
+ * Handles a trailing \<space>
+ * @param glob - glob string
+ * @returns glob string with space to the right removed.
+ */
+function trimGlobRight(glob) {
+    const lenMin1 = glob.length - 1;
+    let i = lenMin1;
+    while (i >= 0 && glob[i] in spaces) {
+        --i;
+    }
+    if (glob[i] === '\\') {
+        ++i;
+    }
+    ++i;
+    return i ? glob.slice(0, i) : '';
+}
+/**
+ * Trim any leading spaces, tabs, line-feeds, or new-lines
+ * @param glob - any string
+ * @returns string with leading spaces removed.
+ */
+function trimGlobLeft(glob) {
+    return glob.trimStart();
+}
+/**
+ * Test if a glob pattern has a leading `**`.
+ * @param glob - the glob
+ * @returns true if the glob pattern starts with `**`
+ */
+function isGlobalGlob(glob) {
+    return isGlobalPatternRegExp.test(glob);
+}
+function hasGlobCharacters(glob) {
+    return hasGlobCharactersRegExp.test(glob);
+}
+function isGlobPart(part) {
+    if (part === GlobPlaceHolders.cwd)
+        return false;
+    return hasGlobCharacters(part);
+}
+/**
+ * Split a glob into a path and a glob portion.
+ * The path portion does not contain any glob characters.
+ * Path might be empty. The glob portion should always be non-empty.
+ * @param glob - glob string pattern
+ * @returns
+ */
+function splitGlob(glob) {
+    const parts = glob.split('/');
+    const p = parts.findIndex(isGlobPart);
+    const s = p < 0 ? parts.length - 1 : p;
+    return createSplitGlob(s ? parts.slice(0, s).join('/') + '/' : undefined, parts.slice(s).join('/'));
+}
+/**
+ * Split a glob into a path and a glob portion.
+ * The path portion does not contain any glob characters.
+ * Path might be empty. The glob portion should always be non-empty.
+ * @param glob - glob string pattern
+ * @param relOnly - Indicates that only `..` and `.` path segments are considered for the path.
+ * @returns
+ */
+function splitGlobRel(glob) {
+    const parts = glob.split('/');
+    if (!parts.includes('..') && !parts.includes('.'))
+        return { path: undefined, glob };
+    const firstGlobPartIdx = parts.findIndex(isGlobPart);
+    const lastRelIdx = Math.max(parts.lastIndexOf('..'), parts.lastIndexOf('.'));
+    const p = firstGlobPartIdx >= 0 ? Math.min(firstGlobPartIdx, lastRelIdx + 1) : lastRelIdx + 1;
+    const s = p < 0 ? parts.length - 1 : p;
+    return createSplitGlob(s ? parts.slice(0, s).join('/') + '/' : undefined, parts.slice(s).join('/'));
+}
+function createSplitGlob(path, glob) {
+    glob = path ? '/' + glob : glob;
+    glob = glob.startsWith('/**') ? glob.slice(1) : glob;
+    return { path, glob };
+}
+function rootToUrl(root, builder) {
+    if (root.startsWith(GlobPlaceHolders.cwd)) {
+        return new URL(builder.normalizeFilePathForUrl(root.replace(GlobPlaceHolders.cwd, '.')), builder.cwd);
+    }
+    return builder.toFileDirURL(root);
+}
+function fixPatternRoot(glob, builder) {
+    // Gets resolved later.
+    if (glob.root.startsWith(GlobPlaceHolders.cwd)) {
+        return glob;
+    }
+    glob.root = builder.urlToFilePathOrHref(rootToUrl(glob.root, builder));
+    return glob;
+}
+/**
+ * Adjust the glob pattern in case it is a file or a relative glob.
+ * @param glob
+ * @param builder
+ * @returns
+ */
+function fixPatternGlob(glob, builder) {
+    const rootURL = builder.toFileURL(glob.root);
+    const split = splitGlobRel(glob.glob);
+    glob.glob = split.glob;
+    if (split.path !== undefined) {
+        const relRootPath = split.path.startsWith('/') ? '.' + split.path : split.path;
+        glob.root = builder.urlToFilePathOrHref(builder.toFileDirURL(relRootPath, glob.root));
+    }
+    fixPatternRelativeToRoot(glob, rootURL, builder);
+}
+function fixPatternRelativeToRoot(glob, root, builder) {
+    if (glob.root.startsWith(GlobPlaceHolders.cwd))
+        return;
+    const rel = builder.relative(root, builder.toFileDirURL(glob.root));
+    if (rel.startsWith('/') || rel.startsWith('../'))
+        return;
+    glob.root = builder.urlToFilePathOrHref(root);
+    glob.glob = rel + glob.glob;
+}
+function filePathOrGlobToGlob(filePathOrGlob, root, builder) {
+    const isGlobalPattern = isGlobalGlob(filePathOrGlob);
+    const { path, glob } = builder.isAbsolute(filePathOrGlob)
+        ? splitGlob(filePathOrGlob)
+        : splitGlobRel(filePathOrGlob);
+    const url = builder.toFileDirURL(path || './', root);
+    return { root: builder.urlToFilePathOrHref(url), glob, isGlobalPattern };
+}
+export const __testing__ = {
+    rebaseGlob,
+    trimGlob,
+    isGlobalGlob,
+};
+//# sourceMappingURL=globHelper.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-glob",
-  "version": "8.9.0",
+  "version": "8.10.0",
   "description": "Glob matcher for cspell",
   "keywords": [
     "cspell",
@@ -11,11 +11,11 @@
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
-  "types": "dist/esm/index.d.ts",
-  "module": "dist/esm/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.js",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js"
+      "import": "./dist/index.js"
     }
   },
   "files": [
@@ -25,18 +25,22 @@
     "!**/__mocks__",
     "!**/test/**",
     "!**/*.test.*",
+    "!**/perf/**",
+    "!**/*.perf.*",
     "!**/*.spec.*",
     "!**/*.map"
   ],
   "scripts": {
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
-    "build": "tsc -b . -f",
-    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "tsc -p .",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "vitest run --coverage",
+    "test:perf": "insight --file \"dist/perf/**/*.perf.{mjs,js}\" -t 1000",
+    "test:perf:ts": "insight --register ts-node/esm --file \"src/perf/**/*.perf.{mts,ts}\" -t 1000",
+    "test:perf:prof": "NODE_ENV=production node --cpu-prof ../../node_modules/perf-insight/bin.mjs --file \"dist/perf/**/*.perf.{mjs,js}\" -t 1000",
     "test:watch": "vitest",
     "test": "vitest run",
-    "watch": "tsc -b . -w -f"
+    "watch": "tsc -p . -w"
   },
   "repository": {
     "type": "git",
@@ -50,10 +54,11 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@cspell/url": "8.10.0",
     "micromatch": "^4.0.7"
   },
   "devDependencies": {
-    "@types/micromatch": "^4.0.7"
+    "@types/micromatch": "^4.0.9"
   },
-  "gitHead": "33c513cf848a61fb1ebcea1b9c67505a31447411"
+  "gitHead": "a5dde6ae7e2ac86ac956220d4b8c39a0e58e1bc6"
 }

package/dist/esm/globHelper.js

@@ -1,258 +0,0 @@
-/* eslint-disable no-irregular-whitespace */
-import * as Path from 'node:path';
-const { posix } = Path;
-const relRegExp = /^\.[\\/]/;
-/** test for glob patterns starting with `**` */
-const isGlobalPatternRegExp = /^!*[*]{2}/;
-/**
- * This function tries its best to determine if `fileOrGlob` is a path to a file or a glob pattern.
- * @param fileOrGlob - file (with absolute path) or glob.
- * @param root - absolute path to the directory that will be considered the root when testing the glob pattern.
- * @param path - optional node path methods - used for testing
- */
-export function fileOrGlobToGlob(fileOrGlob, root, path = Path) {
-    const pathToGlob = path.sep === '\\' ? (p) => p.replaceAll('\\', '/') : (p) => p;
-    const isGlobalPattern = false;
-    if (isGlobPatternWithOptionalRoot(fileOrGlob)) {
-        const useRoot = fileOrGlob.root ?? root;
-        const isGlobalPattern = isGlobPatternWithRoot(fileOrGlob)
-            ? fileOrGlob.isGlobalPattern
-            : isGlobalGlob(fileOrGlob.glob);
-        return { ...fileOrGlob, root: useRoot, isGlobalPattern };
-    }
-    if (doesRootContainPath(root, fileOrGlob, path) || relRegExp.test(fileOrGlob)) {
-        const rel = path.relative(root, path.resolve(root, fileOrGlob));
-        return { glob: pathToGlob(rel), root, isGlobalPattern };
-    }
-    return { glob: pathToGlob(fileOrGlob), root, isGlobalPattern };
-}
-/**
- * Decide if a childPath is contained within a root or at the same level.
- * @param root - absolute path
- * @param childPath - absolute path
- */
-export function doesRootContainPath(root, child, path) {
-    if (child.startsWith(root))
-        return true;
-    const rel = path.relative(root, child);
-    return !rel || (rel !== child && !rel.startsWith('..') && !path.isAbsolute(rel));
-}
-export function isGlobPatternWithOptionalRoot(g) {
-    return typeof g !== 'string' && typeof g.glob === 'string';
-}
-export function isGlobPatternWithRoot(g) {
-    return typeof g.root === 'string' && 'isGlobalPattern' in g;
-}
-export function isGlobPatternNormalized(g) {
-    if (!isGlobPatternWithOptionalRoot(g))
-        return false;
-    if (!isGlobPatternWithRoot(g))
-        return false;
-    const gr = g;
-    return 'rawGlob' in gr && 'rawRoot' in gr && typeof gr.rawGlob === 'string';
-}
-/**
- * @param pattern glob pattern
- * @param nested when true add `**​/<glob>/​**`
- * @returns the set of matching globs.
- */
-function normalizePattern(pattern, nested) {
-    pattern = pattern.replace(/^(!!)+/, '');
-    const isNeg = pattern.startsWith('!');
-    const prefix = isNeg ? '!' : '';
-    pattern = isNeg ? pattern.slice(1) : pattern;
-    const patterns = nested ? normalizePatternNested(pattern) : normalizePatternGeneral(pattern);
-    return patterns.map((p) => prefix + p);
-}
-function normalizePatternNested(pattern) {
-    // no slashes will match files names or folders
-    if (!pattern.includes('/')) {
-        if (pattern === '**')
-            return ['**'];
-        return ['**/' + pattern, '**/' + pattern + '/**'];
-    }
-    const hasLeadingSlash = pattern.startsWith('/');
-    pattern = hasLeadingSlash ? pattern.slice(1) : pattern;
-    if (pattern.endsWith('/')) {
-        // legacy behavior, if it only has a trailing slash, allow matching against a nested directory.
-        return hasLeadingSlash || pattern.slice(0, -1).includes('/') ? [pattern + '**/*'] : ['**/' + pattern + '**/*'];
-    }
-    if (pattern.endsWith('**')) {
-        return [pattern];
-    }
-    return [pattern, pattern + '/**'];
-}
-function normalizePatternGeneral(pattern) {
-    pattern = pattern.startsWith('/') ? pattern.slice(1) : pattern;
-    pattern = pattern.endsWith('/') ? pattern + '**/*' : pattern;
-    return [pattern];
-}
-/**
- *
- * @param patterns - glob patterns to normalize.
- * @param options - Normalization options.
- */
-export function normalizeGlobPatterns(patterns, options) {
-    function* normalize() {
-        for (const glob of patterns) {
-            if (isGlobPatternNormalized(glob)) {
-                yield glob;
-                continue;
-            }
-            yield* normalizeGlobPattern(glob, options);
-        }
-    }
-    return [...normalize()];
-}
-export function normalizeGlobPattern(g, options) {
-    const { root, nodePath: path = Path, nested, cwd = Path.resolve() } = options;
-    g = !isGlobPatternWithOptionalRoot(g) ? { glob: g } : g;
-    const gr = { ...g, root: g.root ?? root };
-    const rawRoot = gr.root;
-    const rawGlob = g.glob;
-    gr.glob = gr.glob.trim(); // trimGlob(g.glob);
-    if (gr.glob.startsWith('${cwd}')) {
-        gr.glob = gr.glob.replace('${cwd}', '');
-        gr.root = '${cwd}';
-    }
-    if (gr.root.startsWith('${cwd}')) {
-        gr.root = path.resolve(gr.root.replace('${cwd}', cwd));
-    }
-    const isGlobalPattern = isGlobalGlob(gr.glob);
-    gr.root = path.resolve(root, path.normalize(gr.root));
-    const globs = normalizePattern(gr.glob, nested);
-    return globs.map((glob) => ({ ...gr, glob, rawGlob, rawRoot, isGlobalPattern }));
-}
-/**
- * Try to adjust the root of a glob to match a new root. If it is not possible, the original glob is returned.
- * Note: this does NOT generate absolutely correct glob patterns. The results are intended to be used as a
- * first pass only filter. Followed by testing against the original glob/root pair.
- * @param glob - glob to map
- * @param root - new root to use if possible
- * @param path - Node Path modules to use (testing only)
- */
-export function normalizeGlobToRoot(glob, root, path) {
-    function relToGlob(relativePath) {
-        return path.sep === '\\' ? relativePath.replaceAll('\\', '/') : relativePath;
-    }
-    if (glob.root === root) {
-        return glob;
-    }
-    const relFromRootToGlob = path.relative(root, glob.root);
-    if (!relFromRootToGlob) {
-        return glob;
-    }
-    if (glob.isGlobalPattern) {
-        return { ...glob, root };
-    }
-    const relFromGlobToRoot = path.relative(glob.root, root);
-    const globIsUnderRoot = relFromRootToGlob[0] !== '.' && !path.isAbsolute(relFromRootToGlob);
-    const rootIsUnderGlob = relFromGlobToRoot[0] !== '.' && !path.isAbsolute(relFromGlobToRoot);
-    // Root and Glob are not in the same part of the directory tree.
-    if (!globIsUnderRoot && !rootIsUnderGlob) {
-        return glob;
-    }
-    const isNeg = glob.glob.startsWith('!');
-    const g = isNeg ? glob.glob.slice(1) : glob.glob;
-    const prefix = isNeg ? '!' : '';
-    // prefix with root
-    if (globIsUnderRoot) {
-        const relGlob = relToGlob(relFromRootToGlob);
-        return {
-            ...glob,
-            glob: prefix + posix.join(relGlob, g),
-            root,
-        };
-    }
-    // The root is under the glob root
-    // The more difficult case, the glob is higher than the root
-    // A best effort is made, but does not do advanced matching.
-    const relGlob = relToGlob(relFromGlobToRoot) + '/';
-    const rebasedGlob = rebaseGlob(g, relGlob);
-    return rebasedGlob ? { ...glob, glob: prefix + rebasedGlob, root } : glob;
-}
-/**
- * Rebase a glob string to a new prefix
- * @param glob - glob string
- * @param rebaseTo - glob prefix
- */
-function rebaseGlob(glob, rebaseTo) {
-    if (!rebaseTo || rebaseTo === '/')
-        return glob;
-    if (glob.startsWith('**'))
-        return glob;
-    rebaseTo = rebaseTo.endsWith('/') ? rebaseTo : rebaseTo + '/';
-    if (glob.startsWith(rebaseTo)) {
-        return glob.slice(rebaseTo.length);
-    }
-    const relParts = rebaseTo.split('/');
-    const globParts = glob.split('/');
-    for (let i = 0; i < relParts.length && i < globParts.length; ++i) {
-        const relSeg = relParts[i];
-        const globSeg = globParts[i];
-        // the empty segment due to the end relGlob / allows for us to test against an empty segment.
-        if (!relSeg || globSeg === '**') {
-            return globParts.slice(i).join('/');
-        }
-        if (relSeg !== globSeg && globSeg !== '*') {
-            break;
-        }
-    }
-    return undefined;
-}
-/**
- * Trims any trailing spaces, tabs, line-feeds, new-lines, and comments
- * @param glob - glob string
- * @returns trimmed glob
- */
-function trimGlob(glob) {
-    glob = glob.replaceAll(/(?<!\\)#.*/g, '');
-    glob = trimGlobLeft(glob);
-    glob = trimGlobRight(glob);
-    return glob;
-}
-const spaces = {
-    ' ': true,
-    '\t': true,
-    '\n': true,
-    '\r': true,
-};
-/**
- * Trim any trailing spaces, tabs, line-feeds, or new-lines
- * Handles a trailing \<space>
- * @param glob - glob string
- * @returns glob string with space to the right removed.
- */
-function trimGlobRight(glob) {
-    const lenMin1 = glob.length - 1;
-    let i = lenMin1;
-    while (i >= 0 && glob[i] in spaces) {
-        --i;
-    }
-    if (glob[i] === '\\' && i < lenMin1) {
-        ++i;
-    }
-    ++i;
-    return i ? glob.slice(0, i) : '';
-}
-/**
- * Trim any leading spaces, tabs, line-feeds, or new-lines
- * @param glob - any string
- * @returns string with leading spaces removed.
- */
-function trimGlobLeft(glob) {
-    let i = 0;
-    while (i < glob.length && glob[i] in spaces) {
-        ++i;
-    }
-    return glob.slice(i);
-}
-function isGlobalGlob(glob) {
-    return isGlobalPatternRegExp.test(glob);
-}
-export const __testing__ = {
-    rebaseGlob,
-    trimGlob,
-    isGlobalGlob,
-};
-//# sourceMappingURL=globHelper.js.map