cspell-glob 6.28.0 → 6.29.0

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

@@ -1,4 +1,4 @@
-import type { GlobMatch, GlobPattern, GlobPatternNormalized, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes';
+import type { GlobMatch, GlobPattern, GlobPatternNormalized, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes.js';
 type Optional<T> = {
     [P in keyof T]?: T[P] | undefined;
 };

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

@@ -29,7 +29,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobMatcher = void 0;
 const micromatch_1 = __importDefault(require("micromatch"));
 const Path = __importStar(require("path"));
-const globHelper_1 = require("./globHelper");
+const globHelper_js_1 = require("./globHelper.js");
 class GlobMatcher {
     constructor(patterns, rootOrOptions, _nodePath) {
         _nodePath = _nodePath ?? Path;
@@ -45,9 +45,9 @@ class GlobMatcher {
             : typeof patterns === 'string'
                 ? patterns.split(/\r?\n/g)
                 : [patterns];
-        const globPatterns = (0, globHelper_1.normalizeGlobPatterns)(patterns, this.options);
+        const globPatterns = (0, globHelper_js_1.normalizeGlobPatterns)(patterns, this.options);
         this.patternsNormalizedToRoot = globPatterns
-            .map((g) => (0, globHelper_1.normalizeGlobToRoot)(g, normalizedRoot, nodePath))
+            .map((g) => (0, globHelper_js_1.normalizeGlobToRoot)(g, normalizedRoot, nodePath))
             // Only keep globs that do not match the root when using exclude mode.
             .filter((g) => nodePath.relative(g.root, normalizedRoot) === '');
         this.patterns = globPatterns;
@@ -108,7 +108,7 @@ function buildMatcherFn(patterns, options) {
                 const pattern = rule.pattern;
                 const root = pattern.root;
                 const isRelPat = !pattern.isGlobalPattern;
-                if (isRelPat && !(0, globHelper_1.doesRootContainPath)(root, filename, path)) {
+                if (isRelPat && !(0, globHelper_js_1.doesRootContainPath)(root, filename, path)) {
                     continue;
                 }
                 const relName = isRelPat ? path.relative(root, filename) : filename;

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

@@ -1,4 +1,4 @@
-import type { GlobPattern, GlobPatternNormalized, GlobPatternWithOptionalRoot, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes';
+import type { GlobPattern, GlobPatternNormalized, GlobPatternWithOptionalRoot, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes.js';
 /**
  * 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.

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { fileOrGlobToGlob, isGlobPatternNormalized, isGlobPatternWithOptionalRoot, isGlobPatternWithRoot, normalizeGlobPatterns, NormalizeOptions, } from './globHelper.js';
+export { GlobMatcher, GlobMatchOptions } from './GlobMatcher.js';
+export * from './GlobMatcherTypes.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/{index.js → cjs/index.js}

@@ -15,13 +15,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobMatcher = exports.normalizeGlobPatterns = exports.isGlobPatternWithRoot = exports.isGlobPatternWithOptionalRoot = exports.isGlobPatternNormalized = exports.fileOrGlobToGlob = void 0;
-var globHelper_1 = require("./globHelper");
-Object.defineProperty(exports, "fileOrGlobToGlob", { enumerable: true, get: function () { return globHelper_1.fileOrGlobToGlob; } });
-Object.defineProperty(exports, "isGlobPatternNormalized", { enumerable: true, get: function () { return globHelper_1.isGlobPatternNormalized; } });
-Object.defineProperty(exports, "isGlobPatternWithOptionalRoot", { enumerable: true, get: function () { return globHelper_1.isGlobPatternWithOptionalRoot; } });
-Object.defineProperty(exports, "isGlobPatternWithRoot", { enumerable: true, get: function () { return globHelper_1.isGlobPatternWithRoot; } });
-Object.defineProperty(exports, "normalizeGlobPatterns", { enumerable: true, get: function () { return globHelper_1.normalizeGlobPatterns; } });
-var GlobMatcher_1 = require("./GlobMatcher");
-Object.defineProperty(exports, "GlobMatcher", { enumerable: true, get: function () { return GlobMatcher_1.GlobMatcher; } });
-__exportStar(require("./GlobMatcherTypes"), exports);
+var globHelper_js_1 = require("./globHelper.js");
+Object.defineProperty(exports, "fileOrGlobToGlob", { enumerable: true, get: function () { return globHelper_js_1.fileOrGlobToGlob; } });
+Object.defineProperty(exports, "isGlobPatternNormalized", { enumerable: true, get: function () { return globHelper_js_1.isGlobPatternNormalized; } });
+Object.defineProperty(exports, "isGlobPatternWithOptionalRoot", { enumerable: true, get: function () { return globHelper_js_1.isGlobPatternWithOptionalRoot; } });
+Object.defineProperty(exports, "isGlobPatternWithRoot", { enumerable: true, get: function () { return globHelper_js_1.isGlobPatternWithRoot; } });
+Object.defineProperty(exports, "normalizeGlobPatterns", { enumerable: true, get: function () { return globHelper_js_1.normalizeGlobPatterns; } });
+var GlobMatcher_js_1 = require("./GlobMatcher.js");
+Object.defineProperty(exports, "GlobMatcher", { enumerable: true, get: function () { return GlobMatcher_js_1.GlobMatcher; } });
+__exportStar(require("./GlobMatcherTypes.js"), exports);
 //# sourceMappingURL=index.js.map

package/dist/esm/GlobMatcher.d.mts

@@ -0,0 +1,94 @@
+import type { GlobMatch, GlobPattern, GlobPatternNormalized, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes.mjs';
+type Optional<T> = {
+    [P in keyof T]?: T[P] | undefined;
+};
+export type GlobMatchOptions = Optional<NormalizedGlobMatchOptions>;
+export type MatcherMode = 'exclude' | 'include';
+interface NormalizedGlobMatchOptions {
+    /**
+     * The matcher has two modes (`include` or `exclude`) that impact how globs behave.
+     *
+     * `include` - designed for searching for file. By default it matches a sub-set of file.
+     *   In include mode, the globs need to be more explicit to match.
+     * - `dot` is by default false.
+     * - `nested` is by default false.
+     *
+     * `exclude` - designed to emulate `.gitignore`. By default it matches a larger range of files.
+     * - `dot` is by default true.
+     * - `nested` is by default true.
+     *
+     * @default: 'exclude'
+     */
+    mode: MatcherMode;
+    /**
+     * The default directory from which a glob is relative.
+     * Any globs that are not relative to the root will ignored.
+     * @default: process.cwd()
+     */
+    root: string;
+    /**
+     * The directory to use as the current working directory.
+     * @default: process.cwd();
+     */
+    cwd: string;
+    /**
+     * Allows matching against directories with a leading `.`.
+     *
+     * @default: mode == 'exclude'
+     */
+    dot: boolean;
+    /**
+     * Allows matching against nested directories or files without needing to add `**`
+     *
+     * @default: mode == 'exclude'
+     */
+    nested: boolean;
+    /**
+     * Mostly used for testing purposes. It allows explicitly specifying `path.win32` or `path.posix`.
+     *
+     * @default: require('path')
+     */
+    nodePath: PathInterface;
+    /**
+     * Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters.
+     *
+     * @default false
+     */
+    nobrace?: boolean | undefined;
+}
+export declare class GlobMatcher {
+    /**
+     * @param filename full path of file to match against.
+     * @returns a GlobMatch - information about the match.
+     */
+    readonly matchEx: (filename: string) => GlobMatch;
+    readonly path: PathInterface;
+    readonly patterns: GlobPatternWithRoot[];
+    readonly patternsNormalizedToRoot: GlobPatternNormalized[];
+    readonly root: string;
+    readonly dot: boolean;
+    readonly options: NormalizedGlobMatchOptions;
+    /**
+     * 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);
+    /**
+     * 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);
+    /**
+     * Check to see if a filename matches any of the globs.
+     * If filename is relative, it is considered relative to the root.
+     * If filename is absolute and contained within the root, it will be made relative before being tested for a glob match.
+     * If filename is absolute and not contained within the root, it will be tested as is.
+     * @param filename full path of the file to check.
+     */
+    match(filename: string): boolean;
+}
+export {};
+//# sourceMappingURL=GlobMatcher.d.mts.map

package/dist/esm/GlobMatcher.mjs

@@ -0,0 +1,101 @@
+import mm from 'micromatch';
+import * as Path from 'path';
+import { doesRootContainPath, normalizeGlobPatterns, normalizeGlobToRoot } from './globHelper.mjs';
+export class GlobMatcher {
+    constructor(patterns, rootOrOptions, _nodePath) {
+        _nodePath = _nodePath ?? Path;
+        const options = typeof rootOrOptions === 'string' ? { root: rootOrOptions } : rootOrOptions ?? {};
+        const { mode = 'exclude' } = options;
+        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));
+        this.options = { root: normalizedRoot, dot, nodePath, nested, mode, nobrace, cwd };
+        patterns = Array.isArray(patterns)
+            ? patterns
+            : typeof patterns === 'string'
+                ? patterns.split(/\r?\n/g)
+                : [patterns];
+        const globPatterns = normalizeGlobPatterns(patterns, this.options);
+        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) === '');
+        this.patterns = globPatterns;
+        this.root = normalizedRoot;
+        this.path = nodePath;
+        this.dot = dot;
+        this.matchEx = buildMatcherFn(this.patterns, this.options);
+    }
+    /**
+     * Check to see if a filename matches any of the globs.
+     * If filename is relative, it is considered relative to the root.
+     * If filename is absolute and contained within the root, it will be made relative before being tested for a glob match.
+     * If filename is absolute and not contained within the root, it will be tested as is.
+     * @param filename full path of the file to check.
+     */
+    match(filename) {
+        return this.matchEx(filename).matched;
+    }
+}
+/**
+ * This function attempts to emulate .gitignore functionality as much as possible.
+ *
+ * The resulting matcher function: (filename: string) => GlobMatch
+ *
+ * If filename is relative, it is considered relative to the root.
+ * If filename is absolute and contained within the root, it will be made relative before being tested for a glob match.
+ * If filename is absolute and not contained within the root, it will return a GlobMatchNoRule.
+ *
+ * @param patterns - the contents of a .gitignore style file or an array of individual glob rules.
+ * @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;
+    const makeReOptions = { dot, nobrace };
+    const rules = patterns
+        .map((pattern, index) => ({ pattern, index }))
+        .filter((r) => !!r.pattern.glob)
+        .filter((r) => !r.pattern.glob.startsWith('#'))
+        .map(({ pattern, index }) => {
+        const matchNeg = pattern.glob.match(/^!/);
+        const glob = pattern.glob.replace(/^!/, '');
+        const isNeg = (matchNeg && matchNeg[0].length & 1 && true) || false;
+        const reg = mm.makeRe(glob, makeReOptions);
+        const fn = (filename) => {
+            const match = filename.match(reg);
+            return !!match;
+        };
+        return { pattern, index, isNeg, fn, reg };
+    });
+    const negRules = rules.filter((r) => r.isNeg);
+    const posRules = rules.filter((r) => !r.isNeg);
+    const fn = (filename) => {
+        filename = path.resolve(path.normalize(filename));
+        function testRules(rules, matched) {
+            for (const rule of rules) {
+                const pattern = rule.pattern;
+                const root = pattern.root;
+                const isRelPat = !pattern.isGlobalPattern;
+                if (isRelPat && !doesRootContainPath(root, filename, path)) {
+                    continue;
+                }
+                const relName = isRelPat ? path.relative(root, filename) : filename;
+                const fname = path.sep === '\\' ? relName.replace(/\\/g, '/') : relName;
+                if (rule.fn(fname)) {
+                    return {
+                        matched,
+                        glob: pattern.glob,
+                        root,
+                        pattern,
+                        index: rule.index,
+                        isNeg: rule.isNeg,
+                    };
+                }
+            }
+        }
+        return testRules(negRules, false) || testRules(posRules, true) || { matched: false };
+    };
+    return fn;
+}

package/dist/esm/GlobMatcherTypes.d.mts

@@ -0,0 +1,55 @@
+export interface PathInterface {
+    normalize(p: string): string;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+    relative(from: string, to: string): string;
+    isAbsolute(p: string): boolean;
+    sep: string;
+}
+export type GlobMatch = GlobMatchRule | GlobMatchNoRule;
+export interface GlobMatchRule {
+    matched: boolean;
+    glob: string;
+    root: string;
+    pattern: GlobPatternWithRoot;
+    index: number;
+    isNeg: boolean;
+}
+export interface GlobMatchNoRule {
+    matched: false;
+}
+export type GlobPattern = SimpleGlobPattern | GlobPatternWithRoot | GlobPatternWithOptionalRoot;
+export type SimpleGlobPattern = string;
+export interface GlobPatternWithOptionalRoot {
+    /**
+     * a glob pattern
+     */
+    glob: string;
+    /**
+     * The root from which the glob pattern is relative.
+     * @default: options.root
+     */
+    root?: string | undefined;
+    /**
+     * Optional value useful for tracing which file a glob pattern was defined in.
+     */
+    source?: string | undefined;
+    /**
+     * Optional line number in the source
+     */
+    line?: number | undefined;
+}
+export interface GlobPatternWithRoot extends GlobPatternWithOptionalRoot {
+    root: string;
+    /**
+     * Global patterns do not need to be relative to the root.
+     */
+    isGlobalPattern: boolean;
+}
+export interface GlobPatternNormalized extends GlobPatternWithRoot {
+    /** the original glob pattern before it was normalized */
+    rawGlob: string;
+    /** the original root */
+    rawRoot: string | undefined;
+}
+//# sourceMappingURL=GlobMatcherTypes.d.mts.map

package/dist/esm/GlobMatcherTypes.mjs

@@ -0,0 +1,2 @@
+// cspell:ignore fname
+export {};

package/dist/esm/globHelper.d.mts

@@ -0,0 +1,73 @@
+import type { GlobPattern, GlobPatternNormalized, GlobPatternWithOptionalRoot, GlobPatternWithRoot, PathInterface } from './GlobMatcherTypes.mjs';
+/**
+ * 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 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 isGlobPatternNormalized(g: GlobPattern | GlobPatternNormalized): g is GlobPatternNormalized;
+export interface NormalizeOptions {
+    /**
+     * Indicates that the glob should be modified to match nested patterns.
+     *
+     * Example: `node_modules` becomes `**​/node_modules/​**`, `**​/node_modules`, and `node_modules/​**`
+     */
+    nested: boolean;
+    /**
+     * This is the root to use for the glob if the glob does not already contain one.
+     */
+    root: string;
+    /**
+     * This is the replacement for `${cwd}` in either the root or in the glob.
+     */
+    cwd?: string;
+    /**
+     * Optional path interface for working with paths.
+     */
+    nodePath?: PathInterface;
+}
+/**
+ *
+ * @param patterns - glob patterns to normalize.
+ * @param options - Normalization options.
+ */
+export declare function normalizeGlobPatterns(patterns: GlobPattern[], options: NormalizeOptions): GlobPatternNormalized[];
+export declare function normalizeGlobPattern(g: GlobPattern, options: NormalizeOptions): GlobPatternNormalized[];
+/**
+ * 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 declare function normalizeGlobToRoot<Glob extends GlobPatternWithRoot>(glob: Glob, root: string, path: PathInterface): Glob;
+/**
+ * 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;
+/**
+ * Trims any trailing spaces, tabs, line-feeds, new-lines, and comments
+ * @param glob - glob string
+ * @returns trimmed glob
+ */
+declare function trimGlob(glob: string): string;
+declare function isGlobalGlob(glob: string): boolean;
+export declare const __testing__: {
+    rebaseGlob: typeof rebaseGlob;
+    trimGlob: typeof trimGlob;
+    isGlobalGlob: typeof isGlobalGlob;
+};
+export {};
+//# sourceMappingURL=globHelper.d.mts.map

package/dist/esm/globHelper.mjs

@@ -0,0 +1,257 @@
+/* eslint-disable no-irregular-whitespace */
+import * as Path from '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.replace(/\\/g, '/') : (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.replace(/\\/g, '/') : 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.replace(/(?<!\\)#.*/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,
+};

package/dist/esm/index.d.mts

@@ -0,0 +1,4 @@
+export { fileOrGlobToGlob, isGlobPatternNormalized, isGlobPatternWithOptionalRoot, isGlobPatternWithRoot, normalizeGlobPatterns, NormalizeOptions, } from './globHelper.mjs';
+export { GlobMatcher, GlobMatchOptions } from './GlobMatcher.mjs';
+export * from './GlobMatcherTypes.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/esm/index.mjs

@@ -0,0 +1,3 @@
+export { fileOrGlobToGlob, isGlobPatternNormalized, isGlobPatternWithOptionalRoot, isGlobPatternWithRoot, normalizeGlobPatterns, } from './globHelper.mjs';
+export { GlobMatcher } from './GlobMatcher.mjs';
+export * from './GlobMatcherTypes.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-glob",
-  "version": "6.28.0",
+  "version": "6.29.0",
   "description": "Glob matcher for cspell",
   "keywords": [
     "cspell",
@@ -9,27 +9,39 @@
   "author": "Jason Dent <jason@streetsidesoftware.nl>",
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-glob#readme",
   "license": "MIT",
-  "main": "dist/index.js",
-  "directories": {
-    "dist": "dist"
+  "type": "commonjs",
+  "main": "dist/cjs/index.js",
+  "types": "dist/cjs/index.d.ts",
+  "module": "dist/esm/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.mjs",
+      "require": "./dist/cjs/index.js"
+    }
   },
-  "typings": "dist/index.d.ts",
   "files": [
+    "bin.mjs",
     "dist",
+    "!dist/esm/**/*.js",
+    "!dist/esm/**/*.ts",
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
+    "!**/test/**",
     "!**/*.test.*",
     "!**/*.spec.*",
     "!**/*.map"
   ],
   "scripts": {
-    "build": "tsc -p .",
-    "watch": "tsc -p . -w",
     "clean": "shx rm -rf dist coverage .tsbuildinfo",
+    "build": "tsc -b . && ts2mjs dist/esm",
+    "build:esm": "tsc -p tsconfig.esm.json",
     "clean-build": "pnpm run clean && pnpm run build",
-    "coverage": "jest --coverage",
-    "test-watch": "jest --watch",
-    "test": "jest"
+    "coverage": "pnpm coverage:vitest && pnpm coverage:fix",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:fix": "nyc report --temp-dir \"$(pwd)/coverage\" --reporter lcov --report-dir \"$(pwd)/coverage\" --cwd ../..",
+    "test:watch": "vitest",
+    "test": "vitest run",
+    "watch": "tsc -b . -w"
   },
   "repository": {
     "type": "git",
@@ -46,7 +58,7 @@
   },
   "devDependencies": {
     "@types/micromatch": "^4.0.2",
-    "jest": "^29.4.3"
+    "jest": "^29.5.0"
   },
-  "gitHead": "1c314413e76908e5fbf61fd2555726112b177c0e"
+  "gitHead": "2eabb1c47c12c2a42eb95d30329be6f544ee2ffc"
 }

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { fileOrGlobToGlob, isGlobPatternNormalized, isGlobPatternWithOptionalRoot, isGlobPatternWithRoot, normalizeGlobPatterns, NormalizeOptions, } from './globHelper';
-export { GlobMatcher, GlobMatchOptions } from './GlobMatcher';
-export * from './GlobMatcherTypes';
-//# sourceMappingURL=index.d.ts.map