minimatch

constructor

constructor(type: ExtglobType, parent?: AST, options?: MinimatchOptions);

property depth

readonly depth: number;

property hasMagic

readonly hasMagic: boolean;

property id

id: number;

property options

readonly options: MinimatchOptions;

property type

type: ExtglobType;

method clone

clone: (parent: AST) => AST;

method copyIn

copyIn: (part: AST | string) => void;

method fromGlob

static fromGlob: (pattern: string, options?: MinimatchOptions) => AST;

method isEnd

isEnd: () => boolean;

method isStart

isStart: () => boolean;

method push

push: (...parts: (string | AST)[]) => void;

method toJSON

toJSON: () => any[];

method toMMPattern

toMMPattern: () => MMRegExp | string;

method toRegExpSource

toRegExpSource: (
    allowDot?: boolean
) => [re: string, body: string, hasMagic: boolean, uflag: boolean];

method toString

toString: () => string;

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 regexp

regexp: false | MMRegExp;

property set

set: ParseReturnFiltered[][];

property windowsNoMagicRoot

windowsNoMagicRoot: boolean;

property windowsPathsNoEscape

windowsPathsNoEscape: boolean;

method adjascentGlobstarOptimize

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

method braceExpand

braceExpand: () => string[];

method debug

debug: (..._: any[]) => void;

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 levelTwoFileOptimize

levelTwoFileOptimize: (parts: string | string[]) => string[];

method make

make: () => void;

method makeRe

makeRe: () => false | MMRegExp;

method match

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

method matchOne

matchOne: (file: string[], pattern: ParseReturn[], partial?: boolean) => boolean;

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[][];

method slashSplit

slashSplit: (p: string) => string[];

property allowWindowsEscape

allowWindowsEscape?: boolean;

• inverse of MinimatchOptions.windowsPathsNoEscape

  Deprecated

property braceExpandMax

braceExpandMax?: number;

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

property debug

debug?: boolean;

• print LOTS of debugging output

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 maxExtglobRecursion

maxExtglobRecursion?: number;

• Max depth to traverse for nested extglobs like *(a|b|c)

  Default is 2, which is quite low, but any higher value swiftly results in punishing performance impacts. Note that this is *not* relevant when the globstar types can be safely coalesced into a single set.

  For example, *(a|@(b|c)|d) would be flattened into *(a|b|c|d). Thus, many common extglobs will retain good performance and never hit this limit, even if they are excessively deep and complicated.

  If the limit is hit, then the extglob characters are simply not parsed, and the pattern effectively switches into noextglob: true mode for the contents of that nested sub-pattern. This will typically _not_ result in a match, but is considered a valid trade-off for security and performance.

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 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