@rse/ase 0.0.41 → 0.0.43

package/plugin/node_modules/fast-glob/out/index.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="node" />
-import * as taskManager from './managers/tasks';
-import { Options as OptionsInternal } from './settings';
-import { Entry as EntryInternal, FileSystemAdapter as FileSystemAdapterInternal, Pattern as PatternInternal } from './types';
-type EntryObjectModePredicate = {
-    [TKey in keyof Pick<OptionsInternal, 'objectMode'>]-?: true;
-};
-type EntryStatsPredicate = {
-    [TKey in keyof Pick<OptionsInternal, 'stats'>]-?: true;
-};
-type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
-declare function FastGlob(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): Promise<EntryInternal[]>;
-declare function FastGlob(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Promise<string[]>;
-declare namespace FastGlob {
-    type Options = OptionsInternal;
-    type Entry = EntryInternal;
-    type Task = taskManager.Task;
-    type Pattern = PatternInternal;
-    type FileSystemAdapter = FileSystemAdapterInternal;
-    const glob: typeof FastGlob;
-    const globSync: typeof sync;
-    const globStream: typeof stream;
-    const async: typeof FastGlob;
-    function sync(source: PatternInternal | PatternInternal[], options: OptionsInternal & EntryObjectPredicate): EntryInternal[];
-    function sync(source: PatternInternal | PatternInternal[], options?: OptionsInternal): string[];
-    function stream(source: PatternInternal | PatternInternal[], options?: OptionsInternal): NodeJS.ReadableStream;
-    function generateTasks(source: PatternInternal | PatternInternal[], options?: OptionsInternal): Task[];
-    function isDynamicPattern(source: PatternInternal, options?: OptionsInternal): boolean;
-    function escapePath(source: string): PatternInternal;
-    function convertPathToPattern(source: string): PatternInternal;
-    namespace posix {
-        function escapePath(source: string): PatternInternal;
-        function convertPathToPattern(source: string): PatternInternal;
-    }
-    namespace win32 {
-        function escapePath(source: string): PatternInternal;
-        function convertPathToPattern(source: string): PatternInternal;
-    }
-}
-export = FastGlob;

package/plugin/node_modules/fast-glob/out/index.js

@@ -1,102 +0,0 @@
-"use strict";
-const taskManager = require("./managers/tasks");
-const async_1 = require("./providers/async");
-const stream_1 = require("./providers/stream");
-const sync_1 = require("./providers/sync");
-const settings_1 = require("./settings");
-const utils = require("./utils");
-async function FastGlob(source, options) {
-    assertPatternsInput(source);
-    const works = getWorks(source, async_1.default, options);
-    const result = await Promise.all(works);
-    return utils.array.flatten(result);
-}
-// https://github.com/typescript-eslint/typescript-eslint/issues/60
-// eslint-disable-next-line no-redeclare
-(function (FastGlob) {
-    FastGlob.glob = FastGlob;
-    FastGlob.globSync = sync;
-    FastGlob.globStream = stream;
-    FastGlob.async = FastGlob;
-    function sync(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, sync_1.default, options);
-        return utils.array.flatten(works);
-    }
-    FastGlob.sync = sync;
-    function stream(source, options) {
-        assertPatternsInput(source);
-        const works = getWorks(source, stream_1.default, options);
-        /**
-         * The stream returned by the provider cannot work with an asynchronous iterator.
-         * To support asynchronous iterators, regardless of the number of tasks, we always multiplex streams.
-         * This affects performance (+25%). I don't see best solution right now.
-         */
-        return utils.stream.merge(works);
-    }
-    FastGlob.stream = stream;
-    function generateTasks(source, options) {
-        assertPatternsInput(source);
-        const patterns = [].concat(source);
-        const settings = new settings_1.default(options);
-        return taskManager.generate(patterns, settings);
-    }
-    FastGlob.generateTasks = generateTasks;
-    function isDynamicPattern(source, options) {
-        assertPatternsInput(source);
-        const settings = new settings_1.default(options);
-        return utils.pattern.isDynamicPattern(source, settings);
-    }
-    FastGlob.isDynamicPattern = isDynamicPattern;
-    function escapePath(source) {
-        assertPatternsInput(source);
-        return utils.path.escape(source);
-    }
-    FastGlob.escapePath = escapePath;
-    function convertPathToPattern(source) {
-        assertPatternsInput(source);
-        return utils.path.convertPathToPattern(source);
-    }
-    FastGlob.convertPathToPattern = convertPathToPattern;
-    let posix;
-    (function (posix) {
-        function escapePath(source) {
-            assertPatternsInput(source);
-            return utils.path.escapePosixPath(source);
-        }
-        posix.escapePath = escapePath;
-        function convertPathToPattern(source) {
-            assertPatternsInput(source);
-            return utils.path.convertPosixPathToPattern(source);
-        }
-        posix.convertPathToPattern = convertPathToPattern;
-    })(posix = FastGlob.posix || (FastGlob.posix = {}));
-    let win32;
-    (function (win32) {
-        function escapePath(source) {
-            assertPatternsInput(source);
-            return utils.path.escapeWindowsPath(source);
-        }
-        win32.escapePath = escapePath;
-        function convertPathToPattern(source) {
-            assertPatternsInput(source);
-            return utils.path.convertWindowsPathToPattern(source);
-        }
-        win32.convertPathToPattern = convertPathToPattern;
-    })(win32 = FastGlob.win32 || (FastGlob.win32 = {}));
-})(FastGlob || (FastGlob = {}));
-function getWorks(source, _Provider, options) {
-    const patterns = [].concat(source);
-    const settings = new settings_1.default(options);
-    const tasks = taskManager.generate(patterns, settings);
-    const provider = new _Provider(settings);
-    return tasks.map(provider.read, provider);
-}
-function assertPatternsInput(input) {
-    const source = [].concat(input);
-    const isValidSource = source.every((item) => utils.string.isString(item) && !utils.string.isEmpty(item));
-    if (!isValidSource) {
-        throw new TypeError('Patterns must be a string (non empty) or an array of strings');
-    }
-}
-module.exports = FastGlob;

package/plugin/node_modules/fast-glob/out/managers/tasks.d.ts

@@ -1,22 +0,0 @@
-import Settings from '../settings';
-import { Pattern, PatternsGroup } from '../types';
-export type Task = {
-    base: string;
-    dynamic: boolean;
-    patterns: Pattern[];
-    positive: Pattern[];
-    negative: Pattern[];
-};
-export declare function generate(input: Pattern[], settings: Settings): Task[];
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-export declare function convertPatternsToTasks(positive: Pattern[], negative: Pattern[], dynamic: boolean): Task[];
-export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
-export declare function getNegativePatternsAsPositive(patterns: Pattern[], ignore: Pattern[]): Pattern[];
-export declare function groupPatternsByBaseDirectory(patterns: Pattern[]): PatternsGroup;
-export declare function convertPatternGroupsToTasks(positive: PatternsGroup, negative: Pattern[], dynamic: boolean): Task[];
-export declare function convertPatternGroupToTask(base: string, positive: Pattern[], negative: Pattern[], dynamic: boolean): Task;

package/plugin/node_modules/fast-glob/out/managers/tasks.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertPatternGroupToTask = exports.convertPatternGroupsToTasks = exports.groupPatternsByBaseDirectory = exports.getNegativePatternsAsPositive = exports.getPositivePatterns = exports.convertPatternsToTasks = exports.generate = void 0;
-const utils = require("../utils");
-function generate(input, settings) {
-    const patterns = processPatterns(input, settings);
-    const ignore = processPatterns(settings.ignore, settings);
-    const positivePatterns = getPositivePatterns(patterns);
-    const negativePatterns = getNegativePatternsAsPositive(patterns, ignore);
-    const staticPatterns = positivePatterns.filter((pattern) => utils.pattern.isStaticPattern(pattern, settings));
-    const dynamicPatterns = positivePatterns.filter((pattern) => utils.pattern.isDynamicPattern(pattern, settings));
-    const staticTasks = convertPatternsToTasks(staticPatterns, negativePatterns, /* dynamic */ false);
-    const dynamicTasks = convertPatternsToTasks(dynamicPatterns, negativePatterns, /* dynamic */ true);
-    return staticTasks.concat(dynamicTasks);
-}
-exports.generate = generate;
-function processPatterns(input, settings) {
-    let patterns = input;
-    /**
-     * The original pattern like `{,*,**,a/*}` can lead to problems checking the depth when matching entry
-     * and some problems with the micromatch package (see fast-glob issues: #365, #394).
-     *
-     * To solve this problem, we expand all patterns containing brace expansion. This can lead to a slight slowdown
-     * in matching in the case of a large set of patterns after expansion.
-     */
-    if (settings.braceExpansion) {
-        patterns = utils.pattern.expandPatternsWithBraceExpansion(patterns);
-    }
-    /**
-     * If the `baseNameMatch` option is enabled, we must add globstar to patterns, so that they can be used
-     * at any nesting level.
-     *
-     * We do this here, because otherwise we have to complicate the filtering logic. For example, we need to change
-     * the pattern in the filter before creating a regular expression. There is no need to change the patterns
-     * in the application. Only on the input.
-     */
-    if (settings.baseNameMatch) {
-        patterns = patterns.map((pattern) => pattern.includes('/') ? pattern : `**/${pattern}`);
-    }
-    /**
-     * This method also removes duplicate slashes that may have been in the pattern or formed as a result of expansion.
-     */
-    return patterns.map((pattern) => utils.pattern.removeDuplicateSlashes(pattern));
-}
-/**
- * Returns tasks grouped by basic pattern directories.
- *
- * Patterns that can be found inside (`./`) and outside (`../`) the current directory are handled separately.
- * This is necessary because directory traversal starts at the base directory and goes deeper.
- */
-function convertPatternsToTasks(positive, negative, dynamic) {
-    const tasks = [];
-    const patternsOutsideCurrentDirectory = utils.pattern.getPatternsOutsideCurrentDirectory(positive);
-    const patternsInsideCurrentDirectory = utils.pattern.getPatternsInsideCurrentDirectory(positive);
-    const outsideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsOutsideCurrentDirectory);
-    const insideCurrentDirectoryGroup = groupPatternsByBaseDirectory(patternsInsideCurrentDirectory);
-    tasks.push(...convertPatternGroupsToTasks(outsideCurrentDirectoryGroup, negative, dynamic));
-    /*
-     * For the sake of reducing future accesses to the file system, we merge all tasks within the current directory
-     * into a global task, if at least one pattern refers to the root (`.`). In this case, the global task covers the rest.
-     */
-    if ('.' in insideCurrentDirectoryGroup) {
-        tasks.push(convertPatternGroupToTask('.', patternsInsideCurrentDirectory, negative, dynamic));
-    }
-    else {
-        tasks.push(...convertPatternGroupsToTasks(insideCurrentDirectoryGroup, negative, dynamic));
-    }
-    return tasks;
-}
-exports.convertPatternsToTasks = convertPatternsToTasks;
-function getPositivePatterns(patterns) {
-    return utils.pattern.getPositivePatterns(patterns);
-}
-exports.getPositivePatterns = getPositivePatterns;
-function getNegativePatternsAsPositive(patterns, ignore) {
-    const negative = utils.pattern.getNegativePatterns(patterns).concat(ignore);
-    const positive = negative.map(utils.pattern.convertToPositivePattern);
-    return positive;
-}
-exports.getNegativePatternsAsPositive = getNegativePatternsAsPositive;
-function groupPatternsByBaseDirectory(patterns) {
-    const group = {};
-    return patterns.reduce((collection, pattern) => {
-        const base = utils.pattern.getBaseDirectory(pattern);
-        if (base in collection) {
-            collection[base].push(pattern);
-        }
-        else {
-            collection[base] = [pattern];
-        }
-        return collection;
-    }, group);
-}
-exports.groupPatternsByBaseDirectory = groupPatternsByBaseDirectory;
-function convertPatternGroupsToTasks(positive, negative, dynamic) {
-    return Object.keys(positive).map((base) => {
-        return convertPatternGroupToTask(base, positive[base], negative, dynamic);
-    });
-}
-exports.convertPatternGroupsToTasks = convertPatternGroupsToTasks;
-function convertPatternGroupToTask(base, positive, negative, dynamic) {
-    return {
-        dynamic,
-        positive,
-        negative,
-        base,
-        patterns: [].concat(positive, negative.map(utils.pattern.convertToNegativePattern))
-    };
-}
-exports.convertPatternGroupToTask = convertPatternGroupToTask;

package/plugin/node_modules/fast-glob/out/providers/async.d.ts

@@ -1,9 +0,0 @@
-import { Task } from '../managers/tasks';
-import { Entry, EntryItem, ReaderOptions } from '../types';
-import ReaderAsync from '../readers/async';
-import Provider from './provider';
-export default class ProviderAsync extends Provider<Promise<EntryItem[]>> {
-    protected _reader: ReaderAsync;
-    read(task: Task): Promise<EntryItem[]>;
-    api(root: string, task: Task, options: ReaderOptions): Promise<Entry[]>;
-}

package/plugin/node_modules/fast-glob/out/providers/async.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const async_1 = require("../readers/async");
-const provider_1 = require("./provider");
-class ProviderAsync extends provider_1.default {
-    constructor() {
-        super(...arguments);
-        this._reader = new async_1.default(this._settings);
-    }
-    async read(task) {
-        const root = this._getRootDirectory(task);
-        const options = this._getReaderOptions(task);
-        const entries = await this.api(root, task, options);
-        return entries.map((entry) => options.transform(entry));
-    }
-    api(root, task, options) {
-        if (task.dynamic) {
-            return this._reader.dynamic(root, options);
-        }
-        return this._reader.static(task.patterns, options);
-    }
-}
-exports.default = ProviderAsync;

package/plugin/node_modules/fast-glob/out/providers/filters/deep.d.ts

@@ -1,16 +0,0 @@
-import { MicromatchOptions, EntryFilterFunction, Pattern } from '../../types';
-import Settings from '../../settings';
-export default class DeepFilter {
-    private readonly _settings;
-    private readonly _micromatchOptions;
-    constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
-    getFilter(basePath: string, positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
-    private _getMatcher;
-    private _getNegativePatternsRe;
-    private _filter;
-    private _isSkippedByDeep;
-    private _getEntryLevel;
-    private _isSkippedSymbolicLink;
-    private _isSkippedByPositivePatterns;
-    private _isSkippedByNegativePatterns;
-}

package/plugin/node_modules/fast-glob/out/providers/filters/deep.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-const partial_1 = require("../matchers/partial");
-class DeepFilter {
-    constructor(_settings, _micromatchOptions) {
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-    }
-    getFilter(basePath, positive, negative) {
-        const matcher = this._getMatcher(positive);
-        const negativeRe = this._getNegativePatternsRe(negative);
-        return (entry) => this._filter(basePath, entry, matcher, negativeRe);
-    }
-    _getMatcher(patterns) {
-        return new partial_1.default(patterns, this._settings, this._micromatchOptions);
-    }
-    _getNegativePatternsRe(patterns) {
-        const affectDepthOfReadingPatterns = patterns.filter(utils.pattern.isAffectDepthOfReadingPattern);
-        return utils.pattern.convertPatternsToRe(affectDepthOfReadingPatterns, this._micromatchOptions);
-    }
-    _filter(basePath, entry, matcher, negativeRe) {
-        if (this._isSkippedByDeep(basePath, entry.path)) {
-            return false;
-        }
-        if (this._isSkippedSymbolicLink(entry)) {
-            return false;
-        }
-        const filepath = utils.path.removeLeadingDotSegment(entry.path);
-        if (this._isSkippedByPositivePatterns(filepath, matcher)) {
-            return false;
-        }
-        return this._isSkippedByNegativePatterns(filepath, negativeRe);
-    }
-    _isSkippedByDeep(basePath, entryPath) {
-        /**
-         * Avoid unnecessary depth calculations when it doesn't matter.
-         */
-        if (this._settings.deep === Infinity) {
-            return false;
-        }
-        return this._getEntryLevel(basePath, entryPath) >= this._settings.deep;
-    }
-    _getEntryLevel(basePath, entryPath) {
-        const entryPathDepth = entryPath.split('/').length;
-        if (basePath === '') {
-            return entryPathDepth;
-        }
-        const basePathDepth = basePath.split('/').length;
-        return entryPathDepth - basePathDepth;
-    }
-    _isSkippedSymbolicLink(entry) {
-        return !this._settings.followSymbolicLinks && entry.dirent.isSymbolicLink();
-    }
-    _isSkippedByPositivePatterns(entryPath, matcher) {
-        return !this._settings.baseNameMatch && !matcher.match(entryPath);
-    }
-    _isSkippedByNegativePatterns(entryPath, patternsRe) {
-        return !utils.pattern.matchAny(entryPath, patternsRe);
-    }
-}
-exports.default = DeepFilter;

package/plugin/node_modules/fast-glob/out/providers/filters/entry.d.ts

@@ -1,17 +0,0 @@
-import Settings from '../../settings';
-import { EntryFilterFunction, MicromatchOptions, Pattern } from '../../types';
-export default class EntryFilter {
-    private readonly _settings;
-    private readonly _micromatchOptions;
-    readonly index: Map<string, undefined>;
-    constructor(_settings: Settings, _micromatchOptions: MicromatchOptions);
-    getFilter(positive: Pattern[], negative: Pattern[]): EntryFilterFunction;
-    private _filter;
-    private _isDuplicateEntry;
-    private _createIndexRecord;
-    private _onlyFileFilter;
-    private _onlyDirectoryFilter;
-    private _isMatchToPatternsSet;
-    private _isMatchToAbsoluteNegative;
-    private _isMatchToPatterns;
-}

package/plugin/node_modules/fast-glob/out/providers/filters/entry.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class EntryFilter {
-    constructor(_settings, _micromatchOptions) {
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this.index = new Map();
-    }
-    getFilter(positive, negative) {
-        const [absoluteNegative, relativeNegative] = utils.pattern.partitionAbsoluteAndRelative(negative);
-        const patterns = {
-            positive: {
-                all: utils.pattern.convertPatternsToRe(positive, this._micromatchOptions)
-            },
-            negative: {
-                absolute: utils.pattern.convertPatternsToRe(absoluteNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true })),
-                relative: utils.pattern.convertPatternsToRe(relativeNegative, Object.assign(Object.assign({}, this._micromatchOptions), { dot: true }))
-            }
-        };
-        return (entry) => this._filter(entry, patterns);
-    }
-    _filter(entry, patterns) {
-        const filepath = utils.path.removeLeadingDotSegment(entry.path);
-        if (this._settings.unique && this._isDuplicateEntry(filepath)) {
-            return false;
-        }
-        if (this._onlyFileFilter(entry) || this._onlyDirectoryFilter(entry)) {
-            return false;
-        }
-        const isMatched = this._isMatchToPatternsSet(filepath, patterns, entry.dirent.isDirectory());
-        if (this._settings.unique && isMatched) {
-            this._createIndexRecord(filepath);
-        }
-        return isMatched;
-    }
-    _isDuplicateEntry(filepath) {
-        return this.index.has(filepath);
-    }
-    _createIndexRecord(filepath) {
-        this.index.set(filepath, undefined);
-    }
-    _onlyFileFilter(entry) {
-        return this._settings.onlyFiles && !entry.dirent.isFile();
-    }
-    _onlyDirectoryFilter(entry) {
-        return this._settings.onlyDirectories && !entry.dirent.isDirectory();
-    }
-    _isMatchToPatternsSet(filepath, patterns, isDirectory) {
-        const isMatched = this._isMatchToPatterns(filepath, patterns.positive.all, isDirectory);
-        if (!isMatched) {
-            return false;
-        }
-        const isMatchedByRelativeNegative = this._isMatchToPatterns(filepath, patterns.negative.relative, isDirectory);
-        if (isMatchedByRelativeNegative) {
-            return false;
-        }
-        const isMatchedByAbsoluteNegative = this._isMatchToAbsoluteNegative(filepath, patterns.negative.absolute, isDirectory);
-        if (isMatchedByAbsoluteNegative) {
-            return false;
-        }
-        return true;
-    }
-    _isMatchToAbsoluteNegative(filepath, patternsRe, isDirectory) {
-        if (patternsRe.length === 0) {
-            return false;
-        }
-        const fullpath = utils.path.makeAbsolute(this._settings.cwd, filepath);
-        return this._isMatchToPatterns(fullpath, patternsRe, isDirectory);
-    }
-    _isMatchToPatterns(filepath, patternsRe, isDirectory) {
-        if (patternsRe.length === 0) {
-            return false;
-        }
-        // Trying to match files and directories by patterns.
-        const isMatched = utils.pattern.matchAny(filepath, patternsRe);
-        // A pattern with a trailling slash can be used for directory matching.
-        // To apply such pattern, we need to add a tralling slash to the path.
-        if (!isMatched && isDirectory) {
-            return utils.pattern.matchAny(filepath + '/', patternsRe);
-        }
-        return isMatched;
-    }
-}
-exports.default = EntryFilter;

package/plugin/node_modules/fast-glob/out/providers/filters/error.d.ts

@@ -1,8 +0,0 @@
-import Settings from '../../settings';
-import { ErrorFilterFunction } from '../../types';
-export default class ErrorFilter {
-    private readonly _settings;
-    constructor(_settings: Settings);
-    getFilter(): ErrorFilterFunction;
-    private _isNonFatalError;
-}

package/plugin/node_modules/fast-glob/out/providers/filters/error.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class ErrorFilter {
-    constructor(_settings) {
-        this._settings = _settings;
-    }
-    getFilter() {
-        return (error) => this._isNonFatalError(error);
-    }
-    _isNonFatalError(error) {
-        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
-    }
-}
-exports.default = ErrorFilter;

package/plugin/node_modules/fast-glob/out/providers/matchers/matcher.d.ts

@@ -1,33 +0,0 @@
-import { Pattern, MicromatchOptions, PatternRe } from '../../types';
-import Settings from '../../settings';
-export type PatternSegment = StaticPatternSegment | DynamicPatternSegment;
-type StaticPatternSegment = {
-    dynamic: false;
-    pattern: Pattern;
-};
-type DynamicPatternSegment = {
-    dynamic: true;
-    pattern: Pattern;
-    patternRe: PatternRe;
-};
-export type PatternSection = PatternSegment[];
-export type PatternInfo = {
-    /**
-     * Indicates that the pattern has a globstar (more than a single section).
-     */
-    complete: boolean;
-    pattern: Pattern;
-    segments: PatternSegment[];
-    sections: PatternSection[];
-};
-export default abstract class Matcher {
-    private readonly _patterns;
-    private readonly _settings;
-    private readonly _micromatchOptions;
-    protected readonly _storage: PatternInfo[];
-    constructor(_patterns: Pattern[], _settings: Settings, _micromatchOptions: MicromatchOptions);
-    private _fillStorage;
-    private _getPatternSegments;
-    private _splitSegmentsIntoSections;
-}
-export {};

package/plugin/node_modules/fast-glob/out/providers/matchers/matcher.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils = require("../../utils");
-class Matcher {
-    constructor(_patterns, _settings, _micromatchOptions) {
-        this._patterns = _patterns;
-        this._settings = _settings;
-        this._micromatchOptions = _micromatchOptions;
-        this._storage = [];
-        this._fillStorage();
-    }
-    _fillStorage() {
-        for (const pattern of this._patterns) {
-            const segments = this._getPatternSegments(pattern);
-            const sections = this._splitSegmentsIntoSections(segments);
-            this._storage.push({
-                complete: sections.length <= 1,
-                pattern,
-                segments,
-                sections
-            });
-        }
-    }
-    _getPatternSegments(pattern) {
-        const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
-        return parts.map((part) => {
-            const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
-            if (!dynamic) {
-                return {
-                    dynamic: false,
-                    pattern: part
-                };
-            }
-            return {
-                dynamic: true,
-                pattern: part,
-                patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
-            };
-        });
-    }
-    _splitSegmentsIntoSections(segments) {
-        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
-    }
-}
-exports.default = Matcher;

package/plugin/node_modules/fast-glob/out/providers/matchers/partial.d.ts

@@ -1,4 +0,0 @@
-import Matcher from './matcher';
-export default class PartialMatcher extends Matcher {
-    match(filepath: string): boolean;
-}

package/plugin/node_modules/fast-glob/out/providers/matchers/partial.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const matcher_1 = require("./matcher");
-class PartialMatcher extends matcher_1.default {
-    match(filepath) {
-        const parts = filepath.split('/');
-        const levels = parts.length;
-        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
-        for (const pattern of patterns) {
-            const section = pattern.sections[0];
-            /**
-             * In this case, the pattern has a globstar and we must read all directories unconditionally,
-             * but only if the level has reached the end of the first group.
-             *
-             * fixtures/{a,b}/**
-             *  ^ true/false  ^ always true
-            */
-            if (!pattern.complete && levels > section.length) {
-                return true;
-            }
-            const match = parts.every((part, index) => {
-                const segment = pattern.segments[index];
-                if (segment.dynamic && segment.patternRe.test(part)) {
-                    return true;
-                }
-                if (!segment.dynamic && segment.pattern === part) {
-                    return true;
-                }
-                return false;
-            });
-            if (match) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-exports.default = PartialMatcher;

package/plugin/node_modules/fast-glob/out/providers/provider.d.ts

@@ -1,19 +0,0 @@
-import { Task } from '../managers/tasks';
-import Settings from '../settings';
-import { MicromatchOptions, ReaderOptions } from '../types';
-import DeepFilter from './filters/deep';
-import EntryFilter from './filters/entry';
-import ErrorFilter from './filters/error';
-import EntryTransformer from './transformers/entry';
-export default abstract class Provider<T> {
-    protected readonly _settings: Settings;
-    readonly errorFilter: ErrorFilter;
-    readonly entryFilter: EntryFilter;
-    readonly deepFilter: DeepFilter;
-    readonly entryTransformer: EntryTransformer;
-    constructor(_settings: Settings);
-    abstract read(_task: Task): T;
-    protected _getRootDirectory(task: Task): string;
-    protected _getReaderOptions(task: Task): ReaderOptions;
-    protected _getMicromatchOptions(): MicromatchOptions;
-}