cspell-glob 7.0.2 → 7.2.0

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

@@ -1,6 +1,6 @@
 import mm from 'micromatch';
 import * as Path from 'path';
-import { doesRootContainPath, normalizeGlobPatterns, normalizeGlobToRoot } from './globHelper.mjs';
+import { doesRootContainPath, normalizeGlobPatterns, normalizeGlobToRoot } from './globHelper.js';
 export class GlobMatcher {
     constructor(patterns, rootOrOptions, _nodePath) {
         _nodePath = _nodePath ?? Path;
@@ -99,3 +99,4 @@ function buildMatcherFn(patterns, options) {
     };
     return fn;
 }
+//# sourceMappingURL=GlobMatcher.js.map

package/dist/esm/GlobMatcherTypes.js

@@ -0,0 +1,3 @@
+// cspell:ignore fname
+export {};
+//# sourceMappingURL=GlobMatcherTypes.js.map

package/dist/esm/{globHelper.mjs → globHelper.js}

@@ -255,3 +255,4 @@ export const __testing__ = {
     trimGlob,
     isGlobalGlob,
 };
+//# sourceMappingURL=globHelper.js.map

package/dist/esm/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-glob",
-  "version": "7.0.2",
+  "version": "7.2.0",
   "description": "Glob matcher for cspell",
   "keywords": [
     "cspell",
@@ -9,21 +9,17 @@
   "author": "Jason Dent <jason@streetsidesoftware.nl>",
   "homepage": "https://github.com/streetsidesoftware/cspell/tree/main/packages/cspell-glob#readme",
   "license": "MIT",
-  "type": "commonjs",
-  "main": "dist/cjs/index.js",
-  "types": "dist/cjs/index.d.ts",
-  "module": "dist/esm/index.mjs",
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "module": "dist/esm/index.js",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.mjs",
-      "require": "./dist/cjs/index.js"
+      "import": "./dist/esm/index.js"
     }
   },
   "files": [
     "bin.mjs",
     "dist",
-    "!dist/esm/**/*.js",
-    "!dist/esm/**/*.ts",
     "!**/*.tsbuildInfo",
     "!**/__mocks__",
     "!**/test/**",
@@ -33,7 +29,7 @@
   ],
   "scripts": {
     "clean": "shx rm -rf dist temp coverage \"*.tsbuildInfo\"",
-    "build": "tsc -b . && ts2mjs dist/esm",
+    "build": "tsc -b .",
     "build:esm": "tsc -p tsconfig.esm.json",
     "clean-build": "pnpm run clean && pnpm run build",
     "coverage": "vitest run --coverage",
@@ -57,5 +53,5 @@
   "devDependencies": {
     "@types/micromatch": "^4.0.2"
   },
-  "gitHead": "25aa083421fc81e4d5b7cedb4755f9b327120cfc"
+  "gitHead": "b08f7ddc3a4aa22cc80c69ca6638b2a943659a31"
 }

package/dist/cjs/GlobMatcher.js

@@ -1,132 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobMatcher = void 0;
-const micromatch_1 = __importDefault(require("micromatch"));
-const Path = __importStar(require("path"));
-const globHelper_js_1 = require("./globHelper.js");
-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 = (0, globHelper_js_1.normalizeGlobPatterns)(patterns, this.options);
-        this.patternsNormalizedToRoot = globPatterns
-            .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;
-        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;
-    }
-}
-exports.GlobMatcher = GlobMatcher;
-/**
- * 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 = micromatch_1.default.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 && !(0, globHelper_js_1.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;
-}
-//# sourceMappingURL=GlobMatcher.js.map

package/dist/cjs/GlobMatcherTypes.js

@@ -1,4 +0,0 @@
-"use strict";
-// cspell:ignore fname
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=GlobMatcherTypes.js.map

package/dist/cjs/globHelper.js

@@ -1,292 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__testing__ = exports.normalizeGlobToRoot = exports.normalizeGlobPattern = exports.normalizeGlobPatterns = exports.isGlobPatternNormalized = exports.isGlobPatternWithRoot = exports.isGlobPatternWithOptionalRoot = exports.doesRootContainPath = exports.fileOrGlobToGlob = void 0;
-/* eslint-disable no-irregular-whitespace */
-const Path = __importStar(require("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
- */
-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 };
-}
-exports.fileOrGlobToGlob = fileOrGlobToGlob;
-/**
- * Decide if a childPath is contained within a root or at the same level.
- * @param root - absolute path
- * @param childPath - absolute path
- */
-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));
-}
-exports.doesRootContainPath = doesRootContainPath;
-function isGlobPatternWithOptionalRoot(g) {
-    return typeof g !== 'string' && typeof g.glob === 'string';
-}
-exports.isGlobPatternWithOptionalRoot = isGlobPatternWithOptionalRoot;
-function isGlobPatternWithRoot(g) {
-    return typeof g.root === 'string' && 'isGlobalPattern' in g;
-}
-exports.isGlobPatternWithRoot = isGlobPatternWithRoot;
-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';
-}
-exports.isGlobPatternNormalized = isGlobPatternNormalized;
-/**
- * @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.
- */
-function normalizeGlobPatterns(patterns, options) {
-    function* normalize() {
-        for (const glob of patterns) {
-            if (isGlobPatternNormalized(glob)) {
-                yield glob;
-                continue;
-            }
-            yield* normalizeGlobPattern(glob, options);
-        }
-    }
-    return [...normalize()];
-}
-exports.normalizeGlobPatterns = normalizeGlobPatterns;
-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 }));
-}
-exports.normalizeGlobPattern = normalizeGlobPattern;
-/**
- * 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)
- */
-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;
-}
-exports.normalizeGlobToRoot = normalizeGlobToRoot;
-/**
- * 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);
-}
-exports.__testing__ = {
-    rebaseGlob,
-    trimGlob,
-    isGlobalGlob,
-};
-//# sourceMappingURL=globHelper.js.map

package/dist/cjs/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobMatcher = exports.normalizeGlobPatterns = exports.isGlobPatternWithRoot = exports.isGlobPatternWithOptionalRoot = exports.isGlobPatternNormalized = exports.fileOrGlobToGlob = void 0;
-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

@@ -1,94 +0,0 @@
-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/GlobMatcherTypes.d.mts

@@ -1,55 +0,0 @@
-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

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

package/dist/esm/globHelper.d.mts

@@ -1,73 +0,0 @@
-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/index.d.mts

@@ -1,4 +0,0 @@
-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

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