minimatch-fast 0.2.1

package/dist/cjs/options.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * @fileoverview Options translator: minimatch options -> picomatch options
+ *
+ * This module handles the translation of minimatch options to picomatch options.
+ * Since minimatch-fast uses picomatch as its matching engine, we need to map
+ * the options from minimatch's API to picomatch's API.
+ *
+ * Key differences between minimatch and picomatch options:
+ * - noext (minimatch) -> noextglob (picomatch)
+ * - matchBase (minimatch) -> basename (picomatch)
+ *
+ * Some options are handled specially and not passed to picomatch:
+ * - nocomment: Comment patterns (handled in Minimatch class)
+ * - nonull: Return pattern when no matches (handled in match function)
+ * - flipNegate: Invert negation result (handled in match function)
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateOptions = translateOptions;
+exports.mergeOptions = mergeOptions;
+/**
+ * Translate minimatch options to picomatch options
+ * Handles naming differences and sets appropriate defaults
+ */
+function translateOptions(opts = {}) {
+    const picoOpts = {
+        // Direct mappings (same name, same meaning)
+        dot: opts.dot,
+        nocase: opts.nocase,
+        nonegate: opts.nonegate,
+        noglobstar: opts.noglobstar,
+        nobrace: opts.nobrace,
+        // Renamed options
+        noextglob: opts.noext, // minimatch: noext -> picomatch: noextglob
+        basename: opts.matchBase, // minimatch: matchBase -> picomatch: basename
+        // Force POSIX mode - we handle Windows paths manually via normalizePath
+        posix: true,
+        // Disable picomatch's brace handling - we use 'braces' package for full expansion
+        // picomatch only does brace matching, not expansion
+        // We expand braces ourselves, so tell picomatch not to process them
+        // Actually, we need nobrace: true to prevent double-processing
+        // The expanded patterns should be matched literally by picomatch
+    };
+    // Special options that need custom handling (not passed to picomatch)
+    const special = {
+        nocomment: opts.nocomment ?? false,
+        nonull: opts.nonull ?? false,
+        flipNegate: opts.flipNegate ?? false,
+        windowsPathsNoEscape: opts.windowsPathsNoEscape ?? opts.allowWindowsEscape === false,
+        partial: opts.partial ?? false,
+        magicalBraces: opts.magicalBraces ?? false,
+        debug: opts.debug ?? false,
+        optimizationLevel: opts.optimizationLevel ?? 1,
+    };
+    return { picoOpts, special };
+}
+/**
+ * Merge options with defaults
+ */
+function mergeOptions(defaults, options) {
+    return { ...defaults, ...options };
+}
+//# sourceMappingURL=options.js.map

package/dist/cjs/options.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.js","sourceRoot":"","sources":["../../src/options.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;GAmBG;;AAQH,4CAqCC;AAKD,oCAKC;AAnDD;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,OAAyB,EAAE;IAC1D,MAAM,QAAQ,GAAqB;QACjC,4CAA4C;QAC5C,GAAG,EAAE,IAAI,CAAC,GAAG;QACb,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;QACvB,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,OAAO,EAAE,IAAI,CAAC,OAAO;QAErB,kBAAkB;QAClB,SAAS,EAAE,IAAI,CAAC,KAAK,EAAE,2CAA2C;QAClE,QAAQ,EAAE,IAAI,CAAC,SAAS,EAAE,8CAA8C;QAExE,wEAAwE;QACxE,KAAK,EAAE,IAAI;QAEX,kFAAkF;QAClF,oDAAoD;QACpD,oEAAoE;QACpE,+DAA+D;QAC/D,iEAAiE;KAClE,CAAC;IAEF,sEAAsE;IACtE,MAAM,OAAO,GAAG;QACd,SAAS,EAAE,IAAI,CAAC,SAAS,IAAI,KAAK;QAClC,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,KAAK;QAC5B,UAAU,EAAE,IAAI,CAAC,UAAU,IAAI,KAAK;QACpC,oBAAoB,EAClB,IAAI,CAAC,oBAAoB,IAAI,IAAI,CAAC,kBAAkB,KAAK,KAAK;QAChE,OAAO,EAAE,IAAI,CAAC,OAAO,IAAI,KAAK;QAC9B,aAAa,EAAE,IAAI,CAAC,aAAa,IAAI,KAAK;QAC1C,KAAK,EAAE,IAAI,CAAC,KAAK,IAAI,KAAK;QAC1B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB,IAAI,CAAC;KAC/C,CAAC;IAEF,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAgB,YAAY,CAC1B,QAA0B,EAC1B,OAAyB;IAEzB,OAAO,EAAE,GAAG,QAAQ,EAAE,GAAG,OAAO,EAAE,CAAC;AACrC,CAAC"}

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview Type definitions for minimatch-fast
+ *
+ * This file contains all TypeScript type definitions used throughout the package.
+ * These types are 100% compatible with minimatch v10.x, ensuring seamless migration
+ * for projects switching from the original minimatch package.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+/**
+ * Supported platforms for path handling
+ */
+export type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
+/**
+ * Path separator types
+ */
+export type Sep = '\\' | '/';
+/**
+ * RegExp with additional metadata
+ */
+export type MMRegExp = RegExp & {
+    _src?: string;
+    _glob?: string;
+};
+/**
+ * Symbol representing globstar pattern (**)
+ */
+export declare const GLOBSTAR: unique symbol;
+export type GlobstarSymbol = typeof GLOBSTAR;
+/**
+ * Parse return types
+ */
+export type ParseReturnFiltered = string | MMRegExp | GlobstarSymbol;
+export type ParseReturn = ParseReturnFiltered | false;
+/**
+ * Options for minimatch functions
+ * All options are optional and default to false unless otherwise specified
+ */
+export interface MinimatchOptions {
+    /**
+     * Do not expand {a,b} and {1..3} brace sets
+     * @default false
+     */
+    nobrace?: boolean;
+    /**
+     * Disable pattern comments starting with #
+     * When false (default), patterns starting with # are treated as comments and match nothing
+     * @default false
+     */
+    nocomment?: boolean;
+    /**
+     * Disable negation with leading !
+     * When false (default), patterns starting with ! are negated
+     * @default false
+     */
+    nonegate?: boolean;
+    /**
+     * Enable debug output
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Disable ** matching across directory separators
+     * When true, ** behaves like *
+     * @default false
+     */
+    noglobstar?: boolean;
+    /**
+     * Disable extglob patterns like +(a|b), *(a|b), ?(a|b), @(a|b), !(a|b)
+     * @default false
+     */
+    noext?: boolean;
+    /**
+     * Return the pattern itself when no matches are found
+     * Only applies to minimatch.match()
+     * @default false
+     */
+    nonull?: boolean;
+    /**
+     * Treat backslash as path separator only, not as escape character
+     * Replaces all \ with / before processing
+     * Useful for Windows paths
+     * @default false
+     */
+    windowsPathsNoEscape?: boolean;
+    /**
+     * Legacy alias: when set to false, enables windowsPathsNoEscape
+     * @deprecated Use windowsPathsNoEscape instead
+     */
+    allowWindowsEscape?: boolean;
+    /**
+     * Perform partial matching
+     * Useful when traversing directories and full path is not yet known
+     * @default false
+     */
+    partial?: boolean;
+    /**
+     * Match patterns without slashes against basename of the path
+     * e.g., *.js will match path/to/file.js
+     * @default false
+     */
+    matchBase?: boolean;
+    /**
+     * Preserve multiple consecutive slashes
+     * By default, multiple slashes are collapsed to one
+     * @default false
+     */
+    preserveMultipleSlashes?: boolean;
+    /**
+     * Match dotfiles (files starting with .)
+     * By default, * and ** do not match dotfiles unless pattern also starts with .
+     * @default false
+     */
+    dot?: boolean;
+    /**
+     * Perform case-insensitive matching
+     * @default false
+     */
+    nocase?: boolean;
+    /**
+     * When used with nocase, only use case-insensitive regex
+     * but leave string comparisons case-sensitive
+     * Has no effect without nocase: true
+     * @default false
+     */
+    nocaseMagicOnly?: boolean;
+    /**
+     * Treat brace expansion as "magic" for hasMagic()
+     * When true, patterns like {a,b} are considered to have magic
+     * @default false
+     */
+    magicalBraces?: boolean;
+    /**
+     * Invert the result of negation
+     * When true, negated patterns return true on hit and false on miss
+     * @default false
+     */
+    flipNegate?: boolean;
+    /**
+     * Optimization level for pattern processing
+     * 0 = no optimization
+     * 1 = basic optimization (default)
+     * 2+ = aggressive optimization
+     * @default 1
+     */
+    optimizationLevel?: number;
+    /**
+     * Override platform detection for path handling
+     */
+    platform?: Platform;
+    /**
+     * Windows-specific: disable magic root detection for drive letters
+     * @default false on non-Windows, true on Windows with nocase
+     */
+    windowsNoMagicRoot?: boolean;
+}
+/**
+ * Options specifically for picomatch (internal use)
+ */
+export interface PicomatchOptions {
+    dot?: boolean;
+    nocase?: boolean;
+    nonegate?: boolean;
+    noextglob?: boolean;
+    noglobstar?: boolean;
+    nobrace?: boolean;
+    basename?: boolean;
+    posix?: boolean;
+    windows?: boolean;
+    contains?: boolean;
+    flags?: string;
+    matchBase?: boolean;
+    posixSlashes?: boolean;
+    expandRange?: (a: string, b: string) => string;
+}
+/**
+ * Result of translating minimatch options to picomatch options
+ */
+export interface TranslatedOptions {
+    picoOpts: PicomatchOptions;
+    special: {
+        nocomment: boolean;
+        nonull: boolean;
+        flipNegate: boolean;
+        windowsPathsNoEscape: boolean;
+        partial: boolean;
+        magicalBraces: boolean;
+        debug: boolean;
+        optimizationLevel: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/cjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/cjs/types.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @fileoverview Type definitions for minimatch-fast
+ *
+ * This file contains all TypeScript type definitions used throughout the package.
+ * These types are 100% compatible with minimatch v10.x, ensuring seamless migration
+ * for projects switching from the original minimatch package.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GLOBSTAR = void 0;
+/**
+ * Symbol representing globstar pattern (**)
+ */
+exports.GLOBSTAR = Symbol('globstar **');
+//# sourceMappingURL=types.js.map

package/dist/cjs/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AA+BH;;GAEG;AACU,QAAA,QAAQ,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC"}

package/dist/cjs/unescape.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Unescape glob magic characters
+ *
+ * This module provides functionality to unescape previously escaped glob strings,
+ * reversing the operation performed by the escape() function.
+ *
+ * Unescape modes:
+ * - Default mode: Removes backslash escaping (\\* -> *)
+ * - Windows mode: Removes character class escaping ([*] -> *)
+ *
+ * This is useful when you need to convert escaped patterns back to their
+ * original form for display or further processing.
+ *
+ * @example
+ * unescape('\\*.js')        // Returns '*.js'
+ * unescape('[*].js', { windowsPathsNoEscape: true })  // Returns '*.js'
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+/**
+ * Un-escape a string that has been escaped with escape().
+ *
+ * If windowsPathsNoEscape is true, square-bracket escapes are removed,
+ * but not backslash escapes (since backslash is a path separator in this mode).
+ *
+ * If windowsPathsNoEscape is false (default), backslash escapes are removed.
+ *
+ * @param str - The string to unescape
+ * @param options - Options controlling unescape behavior
+ * @returns Unescaped string
+ */
+export declare function unescape(str: string, options?: Pick<MinimatchOptions, 'windowsPathsNoEscape'>): string;
+//# sourceMappingURL=unescape.d.ts.map

package/dist/cjs/unescape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unescape.d.ts","sourceRoot":"","sources":["../../src/unescape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACtB,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,IAAI,CAAC,gBAAgB,EAAE,sBAAsB,CAAM,GAC3D,MAAM,CAaR"}

package/dist/cjs/unescape.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * @fileoverview Unescape glob magic characters
+ *
+ * This module provides functionality to unescape previously escaped glob strings,
+ * reversing the operation performed by the escape() function.
+ *
+ * Unescape modes:
+ * - Default mode: Removes backslash escaping (\\* -> *)
+ * - Windows mode: Removes character class escaping ([*] -> *)
+ *
+ * This is useful when you need to convert escaped patterns back to their
+ * original form for display or further processing.
+ *
+ * @example
+ * unescape('\\*.js')        // Returns '*.js'
+ * unescape('[*].js', { windowsPathsNoEscape: true })  // Returns '*.js'
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unescape = unescape;
+/**
+ * Un-escape a string that has been escaped with escape().
+ *
+ * If windowsPathsNoEscape is true, square-bracket escapes are removed,
+ * but not backslash escapes (since backslash is a path separator in this mode).
+ *
+ * If windowsPathsNoEscape is false (default), backslash escapes are removed.
+ *
+ * @param str - The string to unescape
+ * @param options - Options controlling unescape behavior
+ * @returns Unescaped string
+ */
+function unescape(str, options = {}) {
+    const { windowsPathsNoEscape = false } = options;
+    if (windowsPathsNoEscape) {
+        // Remove square-bracket escapes: [x] -> x
+        // But only for single non-special characters
+        // Don't touch things like [abc] or [a-z]
+        return str.replace(/\[([^\/\\[\]{}])\]/g, '$1');
+    }
+    // Default: remove backslash escapes
+    // \x -> x (but not for forward slash which can't be escaped)
+    return str.replace(/\\([^/])/g, '$1');
+}
+//# sourceMappingURL=unescape.js.map

package/dist/cjs/unescape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unescape.js","sourceRoot":"","sources":["../../src/unescape.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;AAgBH,4BAgBC;AA5BD;;;;;;;;;;;GAWG;AACH,SAAgB,QAAQ,CACtB,GAAW,EACX,UAA0D,EAAE;IAE5D,MAAM,EAAE,oBAAoB,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;IAEjD,IAAI,oBAAoB,EAAE,CAAC;QACzB,0CAA0C;QAC1C,6CAA6C;QAC7C,yCAAyC;QACzC,OAAO,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC;IAClD,CAAC;IAED,oCAAoC;IACpC,6DAA6D;IAC7D,OAAO,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC;AACxC,CAAC"}

package/dist/cjs/utils.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Path utilities for cross-platform support
+ *
+ * This module provides utility functions for handling paths across different
+ * operating systems. It includes functions for:
+ * - Platform detection (Windows vs POSIX)
+ * - Path normalization (backslash to forward slash conversion)
+ * - Path splitting with UNC path support
+ * - Glob magic character detection
+ *
+ * These utilities ensure minimatch-fast works correctly on all platforms
+ * while maintaining compatibility with the original minimatch behavior.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { Platform, Sep } from './types';
+/**
+ * Get the default path separator based on platform
+ */
+export declare const sep: Sep;
+/**
+ * Check if the given platform is Windows
+ */
+export declare function isWindows(platform?: Platform): boolean;
+/**
+ * Get the current platform
+ */
+export declare function getPlatform(): Platform;
+/**
+ * Normalize a path by converting backslashes to forward slashes
+ * This is critical for Windows compatibility
+ *
+ * @param path - The path to normalize
+ * @param windowsPathsNoEscape - If true, treat backslash as path separator
+ */
+export declare function normalizePath(path: string, windowsPathsNoEscape: boolean): string;
+/**
+ * Normalize a pattern by converting backslashes to forward slashes
+ *
+ * @param pattern - The pattern to normalize
+ * @param windowsPathsNoEscape - If true, treat backslash as path separator
+ */
+export declare function normalizePattern(pattern: string, windowsPathsNoEscape: boolean): string;
+/**
+ * Split a path by slashes
+ *
+ * @param path - The path to split
+ * @param preserveMultipleSlashes - If true, don't collapse multiple slashes
+ * @param isWindowsPlatform - If true, handle UNC paths
+ */
+export declare function slashSplit(path: string, preserveMultipleSlashes: boolean, isWindowsPlatform: boolean): string[];
+/**
+ * Check if a pattern contains glob magic characters
+ */
+export declare function hasMagicChars(pattern: string): boolean;
+/**
+ * Unescape a string for regex use
+ */
+export declare function escapeRegex(str: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/cjs/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,SAAS,CAAC;AAc7C;;GAEG;AACH,eAAO,MAAM,GAAG,EAAE,GAA8C,CAAC;AAEjE;;GAEG;AACH,wBAAgB,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAEtD;AAED;;GAEG;AACH,wBAAgB,WAAW,IAAI,QAAQ,CAEtC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,oBAAoB,EAAE,OAAO,GAC5B,MAAM,CAUR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,oBAAoB,EAAE,OAAO,GAC5B,MAAM,CAKR;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,uBAAuB,EAAE,OAAO,EAChC,iBAAiB,EAAE,OAAO,GACzB,MAAM,EAAE,CA4BV;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAGtD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE/C"}

package/dist/cjs/utils.js

@@ -0,0 +1,126 @@
+"use strict";
+/**
+ * @fileoverview Path utilities for cross-platform support
+ *
+ * This module provides utility functions for handling paths across different
+ * operating systems. It includes functions for:
+ * - Platform detection (Windows vs POSIX)
+ * - Path normalization (backslash to forward slash conversion)
+ * - Path splitting with UNC path support
+ * - Glob magic character detection
+ *
+ * These utilities ensure minimatch-fast works correctly on all platforms
+ * while maintaining compatibility with the original minimatch behavior.
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sep = void 0;
+exports.isWindows = isWindows;
+exports.getPlatform = getPlatform;
+exports.normalizePath = normalizePath;
+exports.normalizePattern = normalizePattern;
+exports.slashSplit = slashSplit;
+exports.hasMagicChars = hasMagicChars;
+exports.escapeRegex = escapeRegex;
+/**
+ * Detect the current platform
+ */
+const defaultPlatform = (typeof process === 'object' &&
+    process &&
+    typeof process.platform === 'string'
+    ? process.env['__MINIMATCH_TESTING_PLATFORM__'] ||
+        process.platform
+    : 'linux');
+/**
+ * Get the default path separator based on platform
+ */
+exports.sep = defaultPlatform === 'win32' ? '\\' : '/';
+/**
+ * Check if the given platform is Windows
+ */
+function isWindows(platform) {
+    return (platform || defaultPlatform) === 'win32';
+}
+/**
+ * Get the current platform
+ */
+function getPlatform() {
+    return defaultPlatform;
+}
+/**
+ * Normalize a path by converting backslashes to forward slashes
+ * This is critical for Windows compatibility
+ *
+ * @param path - The path to normalize
+ * @param windowsPathsNoEscape - If true, treat backslash as path separator
+ */
+function normalizePath(path, windowsPathsNoEscape) {
+    if (typeof path !== 'string')
+        return path;
+    // If windowsPathsNoEscape is true, convert all backslashes to forward slashes
+    // This matches minimatch behavior where backslash is path separator, not escape
+    if (windowsPathsNoEscape) {
+        return path.replace(/\\/g, '/');
+    }
+    return path;
+}
+/**
+ * Normalize a pattern by converting backslashes to forward slashes
+ *
+ * @param pattern - The pattern to normalize
+ * @param windowsPathsNoEscape - If true, treat backslash as path separator
+ */
+function normalizePattern(pattern, windowsPathsNoEscape) {
+    if (windowsPathsNoEscape) {
+        return pattern.replace(/\\/g, '/');
+    }
+    return pattern;
+}
+/**
+ * Split a path by slashes
+ *
+ * @param path - The path to split
+ * @param preserveMultipleSlashes - If true, don't collapse multiple slashes
+ * @param isWindowsPlatform - If true, handle UNC paths
+ */
+function slashSplit(path, preserveMultipleSlashes, isWindowsPlatform) {
+    // Handle empty path
+    if (!path) {
+        return [''];
+    }
+    // If preserving multiple slashes, just split on single slash
+    if (preserveMultipleSlashes) {
+        return path.split('/');
+    }
+    // Handle UNC paths on Windows (e.g., //server/share)
+    if (isWindowsPlatform && /^\/\/[^/]+/.test(path)) {
+        // Preserve the leading // for UNC paths
+        const parts = path.split(/\/+/);
+        // First element will be empty string from leading //, keep it
+        return ['', ...parts.filter((p, i) => i === 0 || p !== '')];
+    }
+    // Normal case: split on one or more slashes, filter empty parts except leading
+    const parts = path.split(/\/+/);
+    // Handle absolute paths (preserve leading empty string)
+    if (path.startsWith('/')) {
+        return ['', ...parts.filter((p) => p !== '')];
+    }
+    return parts.filter((p) => p !== '');
+}
+/**
+ * Check if a pattern contains glob magic characters
+ */
+function hasMagicChars(pattern) {
+    // Check for glob special characters
+    return /[*?[\]{}()!@+]/.test(pattern);
+}
+/**
+ * Unescape a string for regex use
+ */
+function escapeRegex(str) {
+    return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+}
+//# sourceMappingURL=utils.js.map

package/dist/cjs/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"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"}

package/dist/esm/brace-expand.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @fileoverview Brace expansion using the 'braces' package
+ *
+ * This module is critical because picomatch does NOT perform full brace expansion.
+ * picomatch only does brace matching, meaning {a,b} will match 'a' or 'b'
+ * but won't expand the pattern into ['a', 'b'].
+ *
+ * minimatch uses brace-expansion to fully expand patterns like:
+ * - {a,b,c} -> ['a', 'b', 'c']
+ * - {1..3} -> ['1', '2', '3']
+ * - {a..c} -> ['a', 'b', 'c']
+ * - a{b,c}d -> ['abd', 'acd']
+ *
+ * We use 'braces' package which is maintained by the same author as picomatch
+ * and is what micromatch uses internally.
+ *
+ * Security considerations:
+ * - Maximum expansion length is limited to prevent DoS attacks
+ * - Range expansion is limited (e.g., {1..1000000} is restricted)
+ *
+ * @author 686f6c61
+ * @see https://github.com/686f6c61/minimatch-fast
+ * @license MIT
+ */
+import type { MinimatchOptions } from './types.js';
+/**
+ * Expand brace patterns like {a,b,c} and {1..3}
+ *
+ * Optimized with:
+ * 1. Cache for repeated patterns
+ * 2. Fast path for simple {a,b,c} patterns
+ *
+ * @param pattern - The glob pattern to expand
+ * @param options - Minimatch options
+ * @returns Array of expanded patterns
+ */
+export declare function braceExpand(pattern: string, options?: MinimatchOptions): string[];
+/**
+ * Check if a pattern contains brace expansion syntax
+ */
+export declare function hasBraces(pattern: string): boolean;
+//# sourceMappingURL=brace-expand.d.ts.map

package/dist/esm/brace-expand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"brace-expand.d.ts","sourceRoot":"","sources":["../../src/brace-expand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAyCnD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,gBAAqB,GAC7B,MAAM,EAAE,CAsEV;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CA8BlD"}