minimatch

constructor

constructor(pattern: string, options?: MinimatchOptions);

property comment

comment: boolean;

property empty

empty: boolean;

property globParts

globParts: string[][];

property globSet

globSet: string[];

property isWindows

isWindows: boolean;

property maxGlobstarRecursion

maxGlobstarRecursion: number;

property negate

negate: boolean;

property nocase

nocase: boolean;

property nonegate

nonegate: boolean;

property options

options: MinimatchOptions;

property partial

partial: boolean;

property pattern

pattern: string;

property platform

platform: Platform;

property preserveMultipleSlashes

preserveMultipleSlashes: boolean;

property set

set: any[][];

property windowsNoMagicRoot

windowsNoMagicRoot: boolean;

property windowsPathsNoEscape

windowsPathsNoEscape: boolean;

method adjascentGlobstarOptimize

adjascentGlobstarOptimize: (globParts: string[][]) => string[][];

method braceExpand

braceExpand: () => string[];

method defaults

static defaults: (def: MinimatchOptions) => typeof Minimatch;

method firstPhasePreProcess

firstPhasePreProcess: (globParts: string[][]) => string[][];

method hasMagic

hasMagic: () => boolean;

method levelOneOptimize

levelOneOptimize: (globParts: string[][]) => string[][];

method make

make: () => void;

method match

match: (f: string, partial?: boolean) => boolean;

method mergeRows

mergeRows: () => void;

method parse

parse: (pattern: string) => ParseReturn;

method parseNegate

parseNegate: () => void;

method partsMatch

partsMatch: (
    a: string[],
    b: string[],
    emptyGSMatch?: boolean
) => false | string[];

method preprocess

preprocess: (globParts: string[][]) => string[][];

method secondPhasePreProcess

secondPhasePreProcess: (globParts: string[][]) => string[][];

property allowWindowsEscape

allowWindowsEscape?: boolean;

• inverse of MinimatchOptions.windowsPathsNoEscape

  Deprecated

property braceExpandMax

braceExpandMax?: number;

• max number of {...} patterns to expand. Default 100_000.

  At optimizationLevel 2 or higher, this also limits the patterns made when ** is followed by ...

property dot

dot?: boolean;

• allow matches that start with . even if the pattern does not

property flipNegate

flipNegate?: boolean;

• invert the results of negated matches

property magicalBraces

magicalBraces?: boolean;

• consider braces to be "magic" for the purpose of hasMagic

property matchBase

matchBase?: boolean;

• If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. For example, a?b would match the path /xyz/123/acb, but not /xyz/acb/123.

property maxGlobstarRecursion

maxGlobstarRecursion?: number;

• Max number of non-adjacent ** patterns to recursively walk down.

  The default of 200 is almost certainly high enough for most purposes, and can handle absurdly excessive patterns.

property nobrace

nobrace?: boolean;

• do not expand {x,y} style braces

property nocase

nocase?: boolean;

• ignore case

property nocaseMagicOnly

nocaseMagicOnly?: boolean;

• ignore case only in wildcard patterns

property nocomment

nocomment?: boolean;

• do not treat patterns starting with # as a comment

property noext

noext?: boolean;

• do not expand extglobs like +(a|b)

property noglobstar

noglobstar?: boolean;

• treat ** the same as *

property nonegate

nonegate?: boolean;

• do not treat patterns starting with ! as a negation

property nonull

nonull?: boolean;

• return the pattern if nothing matches

property normalize

normalize?: boolean | Form;

• Normalize unicode in the pattern and in each portion of the tested paths, with this form. true means 'NFC'.

property optimizationLevel

optimizationLevel?: number;

• A number indicating the level of optimization that should be done to the pattern prior to parsing and using it for matches.

property partial

partial?: boolean;

• Compare a partial path to a pattern. As long as the parts of the path that are present are not contradicted by the pattern, it will be treated as a match. This is useful in applications where you're walking through a folder structure, and don't yet have the full path, but want to ensure that you do not walk down paths that can never be a match.

property platform

platform?: Platform;

• operating system platform

property preserveMultipleSlashes

preserveMultipleSlashes?: boolean;

• do not collapse multiple / into a single /

property windowsNoMagicRoot

windowsNoMagicRoot?: boolean;

• When a pattern starts with a UNC path or drive letter, and in nocase:true mode, do not convert the root portions of the pattern into a case-insensitive regular expression, and instead leave them as strings.

  This is the default when the platform is win32 and nocase:true is set.

property windowsPathsNoEscape

windowsPathsNoEscape?: boolean;

• treat \\ as a path separator, not an escape character