claude-flow-novice 2.0.8 → 2.1.0

package/dist/src/web/frontend/node_modules/@humanwhocodes/config-array/api.js

@@ -1,1128 +0,0 @@
-'use strict';
-
-var path = require('path');
-var minimatch = require('minimatch');
-var createDebug = require('debug');
-var objectSchema = require('@humanwhocodes/object-schema');
-
-/**
- * @fileoverview ConfigSchema
- * @author Nicholas C. Zakas
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const NOOP_STRATEGY = {
-	required: false,
-	merge() {
-		return undefined;
-	},
-	validate() { }
-};
-
-//------------------------------------------------------------------------------
-// Exports
-//------------------------------------------------------------------------------
-
-/**
- * The base schema that every ConfigArray uses.
- * @type Object
- */
-const baseSchema = Object.freeze({
-	name: {
-		required: false,
-		merge() {
-			return undefined;
-		},
-		validate(value) {
-			if (typeof value !== 'string') {
-				throw new TypeError('Property must be a string.');
-			}
-		}
-	},
-	files: NOOP_STRATEGY,
-	ignores: NOOP_STRATEGY
-});
-
-/**
- * @fileoverview ConfigSchema
- * @author Nicholas C. Zakas
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Asserts that a given value is an array.
- * @param {*} value The value to check.
- * @returns {void}
- * @throws {TypeError} When the value is not an array.
- */
-function assertIsArray(value) {
-	if (!Array.isArray(value)) {
-		throw new TypeError('Expected value to be an array.');
-	}
-}
-
-/**
- * Asserts that a given value is an array containing only strings and functions.
- * @param {*} value The value to check.
- * @returns {void}
- * @throws {TypeError} When the value is not an array of strings and functions.
- */
-function assertIsArrayOfStringsAndFunctions(value, name) {
-	assertIsArray(value);
-
-	if (value.some(item => typeof item !== 'string' && typeof item !== 'function')) {
-		throw new TypeError('Expected array to only contain strings and functions.');
-	}
-}
-
-/**
- * Asserts that a given value is a non-empty array.
- * @param {*} value The value to check.
- * @returns {void}
- * @throws {TypeError} When the value is not an array or an empty array.
- */
-function assertIsNonEmptyArray(value) {
-	if (!Array.isArray(value) || value.length === 0) {
-		throw new TypeError('Expected value to be a non-empty array.');
-	}
-}
-
-//------------------------------------------------------------------------------
-// Exports
-//------------------------------------------------------------------------------
-
-/**
- * The schema for `files` and `ignores` that every ConfigArray uses.
- * @type Object
- */
-const filesAndIgnoresSchema = Object.freeze({
-	files: {
-		required: false,
-		merge() {
-			return undefined;
-		},
-		validate(value) {
-
-			// first check if it's an array
-			assertIsNonEmptyArray(value);
-
-			// then check each member
-			value.forEach(item => {
-				if (Array.isArray(item)) {
-					assertIsArrayOfStringsAndFunctions(item);
-				} else if (typeof item !== 'string' && typeof item !== 'function') {
-					throw new TypeError('Items must be a string, a function, or an array of strings and functions.');
-				}
-			});
-
-		}
-	},
-	ignores: {
-		required: false,
-		merge() {
-			return undefined;
-		},
-		validate: assertIsArrayOfStringsAndFunctions
-	}
-});
-
-/**
- * @fileoverview ConfigArray
- * @author Nicholas C. Zakas
- */
-
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const Minimatch = minimatch.Minimatch;
-const minimatchCache = new Map();
-const negatedMinimatchCache = new Map();
-const debug = createDebug('@hwc/config-array');
-
-const MINIMATCH_OPTIONS = {
-	// matchBase: true,
-	dot: true
-};
-
-const CONFIG_TYPES = new Set(['array', 'function']);
-
-/**
- * Fields that are considered metadata and not part of the config object.
- */
-const META_FIELDS = new Set(['name']);
-
-const FILES_AND_IGNORES_SCHEMA = new objectSchema.ObjectSchema(filesAndIgnoresSchema);
-
-/**
- * Wrapper error for config validation errors that adds a name to the front of the
- * error message.
- */
-class ConfigError extends Error {
-
-	/**
-	 * Creates a new instance.
-	 * @param {string} name The config object name causing the error.
-	 * @param {number} index The index of the config object in the array.
-	 * @param {Error} source The source error. 
-	 */
-	constructor(name, index, { cause, message }) {
-
-
-		const finalMessage = message || cause.message;
-
-		super(`Config ${name}: ${finalMessage}`, { cause });
-
-		// copy over custom properties that aren't represented
-		if (cause) {
-			for (const key of Object.keys(cause)) {
-				if (!(key in this)) {
-					this[key] = cause[key];
-				}
-			}
-		}
-
-		/**
-		 * The name of the error.
-		 * @type {string}
-		 * @readonly
-		 */
-		this.name = 'ConfigError';
-
-		/**
-		 * The index of the config object in the array.
-		 * @type {number}
-		 * @readonly
-		 */
-		this.index = index;
-	}
-}
-
-/**
- * Gets the name of a config object.
- * @param {object} config The config object to get the name of.
- * @returns {string} The name of the config object.
- */ 
-function getConfigName(config) {
-	if (config && typeof config.name === 'string' && config.name) {
-		return `"${config.name}"`;
-	}
-
-	return '(unnamed)';
-}
-
-/**
- * Rethrows a config error with additional information about the config object.
- * @param {object} config The config object to get the name of. 
- * @param {number} index The index of the config object in the array.
- * @param {Error} error The error to rethrow.
- * @throws {ConfigError} When the error is rethrown for a config.
- */
-function rethrowConfigError(config, index, error) {
-	const configName = getConfigName(config);
-	throw new ConfigError(configName, index, error);
-}
-
-/**
- * Shorthand for checking if a value is a string.
- * @param {any} value The value to check.
- * @returns {boolean} True if a string, false if not. 
- */
-function isString(value) {
-	return typeof value === 'string';
-}
-
-/**
- * Creates a function that asserts that the config is valid
- * during normalization. This checks that the config is not nullish
- * and that files and ignores keys  of a config object are valid as per base schema.
- * @param {Object} config The config object to check.
- * @param {number} index The index of the config object in the array.
- * @returns {void}
- * @throws {ConfigError} If the files and ignores keys of a config object are not valid.
- */
-function assertValidBaseConfig(config, index) {
-
-	if (config === null) {
-		throw new ConfigError(getConfigName(config), index, { message: 'Unexpected null config.' });
-	}
-
-	if (config === undefined) {
-		throw new ConfigError(getConfigName(config), index, { message: 'Unexpected undefined config.' });
-	}
-
-	if (typeof config !== 'object') {
-		throw new ConfigError(getConfigName(config), index, { message: 'Unexpected non-object config.' });
-	}
-
-	const validateConfig = { };
-	
-	if ('files' in config) {
-		validateConfig.files = config.files;
-	}
-	
-	if ('ignores' in config) {
-		validateConfig.ignores = config.ignores;
-	}
-
-	try {
-		FILES_AND_IGNORES_SCHEMA.validate(validateConfig);
-	} catch (validationError) {
-		rethrowConfigError(config, index, { cause: validationError });
-	}
-}
-
-/**
- * Wrapper around minimatch that caches minimatch patterns for
- * faster matching speed over multiple file path evaluations.
- * @param {string} filepath The file path to match.
- * @param {string} pattern The glob pattern to match against.
- * @param {object} options The minimatch options to use.
- * @returns 
- */
-function doMatch(filepath, pattern, options = {}) {
-
-	let cache = minimatchCache;
-
-	if (options.flipNegate) {
-		cache = negatedMinimatchCache;
-	}
-
-	let matcher = cache.get(pattern);
-
-	if (!matcher) {
-		matcher = new Minimatch(pattern, Object.assign({}, MINIMATCH_OPTIONS, options));
-		cache.set(pattern, matcher);
-	}
-
-	return matcher.match(filepath);
-}
-
-/**
- * Normalizes a `ConfigArray` by flattening it and executing any functions
- * that are found inside.
- * @param {Array} items The items in a `ConfigArray`.
- * @param {Object} context The context object to pass into any function
- *      found.
- * @param {Array<string>} extraConfigTypes The config types to check.
- * @returns {Promise<Array>} A flattened array containing only config objects.
- * @throws {TypeError} When a config function returns a function.
- */
-async function normalize(items, context, extraConfigTypes) {
-
-	const allowFunctions = extraConfigTypes.includes('function');
-	const allowArrays = extraConfigTypes.includes('array');
-
-	async function* flatTraverse(array) {
-		for (let item of array) {
-			if (typeof item === 'function') {
-				if (!allowFunctions) {
-					throw new TypeError('Unexpected function.');
-				}
-
-				item = item(context);
-				if (item.then) {
-					item = await item;
-				}
-			}
-
-			if (Array.isArray(item)) {
-				if (!allowArrays) {
-					throw new TypeError('Unexpected array.');
-				}
-				yield* flatTraverse(item);
-			} else if (typeof item === 'function') {
-				throw new TypeError('A config function can only return an object or array.');
-			} else {
-				yield item;
-			}
-		}
-	}
-
-	/*
-	 * Async iterables cannot be used with the spread operator, so we need to manually
-	 * create the array to return.
-	 */
-	const asyncIterable = await flatTraverse(items);
-	const configs = [];
-
-	for await (const config of asyncIterable) {
-		configs.push(config);
-	}
-
-	return configs;
-}
-
-/**
- * Normalizes a `ConfigArray` by flattening it and executing any functions
- * that are found inside.
- * @param {Array} items The items in a `ConfigArray`.
- * @param {Object} context The context object to pass into any function
- *      found.
- * @param {Array<string>} extraConfigTypes The config types to check.
- * @returns {Array} A flattened array containing only config objects.
- * @throws {TypeError} When a config function returns a function.
- */
-function normalizeSync(items, context, extraConfigTypes) {
-
-	const allowFunctions = extraConfigTypes.includes('function');
-	const allowArrays = extraConfigTypes.includes('array');
-
-	function* flatTraverse(array) {
-		for (let item of array) {
-			if (typeof item === 'function') {
-
-				if (!allowFunctions) {
-					throw new TypeError('Unexpected function.');
-				}
-
-				item = item(context);
-				if (item.then) {
-					throw new TypeError('Async config functions are not supported.');
-				}
-			}
-
-			if (Array.isArray(item)) {
-
-				if (!allowArrays) {
-					throw new TypeError('Unexpected array.');
-				}
-
-				yield* flatTraverse(item);
-			} else if (typeof item === 'function') {
-				throw new TypeError('A config function can only return an object or array.');
-			} else {
-				yield item;
-			}
-		}
-	}
-
-	return [...flatTraverse(items)];
-}
-
-/**
- * Determines if a given file path should be ignored based on the given
- * matcher.
- * @param {Array<string|() => boolean>} ignores The ignore patterns to check. 
- * @param {string} filePath The absolute path of the file to check.
- * @param {string} relativeFilePath The relative path of the file to check.
- * @returns {boolean} True if the path should be ignored and false if not.
- */
-function shouldIgnorePath(ignores, filePath, relativeFilePath) {
-
-	// all files outside of the basePath are ignored
-	if (relativeFilePath.startsWith('..')) {
-		return true;
-	}
-
-	return ignores.reduce((ignored, matcher) => {
-
-		if (!ignored) {
-
-			if (typeof matcher === 'function') {
-				return matcher(filePath);
-			}
-
-			// don't check negated patterns because we're not ignored yet
-			if (!matcher.startsWith('!')) {
-				return doMatch(relativeFilePath, matcher);
-			}
-
-			// otherwise we're still not ignored
-			return false;
-
-		}
-
-		// only need to check negated patterns because we're ignored
-		if (typeof matcher === 'string' && matcher.startsWith('!')) {
-			return !doMatch(relativeFilePath, matcher, {
-				flipNegate: true
-			});
-		}
-
-		return ignored;
-
-	}, false);
-
-}
-
-/**
- * Determines if a given file path is matched by a config based on
- * `ignores` only.
- * @param {string} filePath The absolute file path to check.
- * @param {string} basePath The base path for the config.
- * @param {Object} config The config object to check.
- * @returns {boolean} True if the file path is matched by the config,
- *      false if not.
- */
-function pathMatchesIgnores(filePath, basePath, config) {
-
-	/*
-	 * For both files and ignores, functions are passed the absolute
-	 * file path while strings are compared against the relative
-	 * file path.
-	 */
-	const relativeFilePath = path.relative(basePath, filePath);
-
-	return Object.keys(config).filter(key => !META_FIELDS.has(key)).length > 1 &&
-		!shouldIgnorePath(config.ignores, filePath, relativeFilePath);
-}
-
-
-/**
- * Determines if a given file path is matched by a config. If the config
- * has no `files` field, then it matches; otherwise, if a `files` field
- * is present then we match the globs in `files` and exclude any globs in
- * `ignores`.
- * @param {string} filePath The absolute file path to check.
- * @param {string} basePath The base path for the config.
- * @param {Object} config The config object to check.
- * @returns {boolean} True if the file path is matched by the config,
- *      false if not.
- */
-function pathMatches(filePath, basePath, config) {
-
-	/*
-	 * For both files and ignores, functions are passed the absolute
-	 * file path while strings are compared against the relative
-	 * file path.
-	 */
-	const relativeFilePath = path.relative(basePath, filePath);
-
-	// match both strings and functions
-	const match = pattern => {
-
-		if (isString(pattern)) {
-			return doMatch(relativeFilePath, pattern);
-		}
-
-		if (typeof pattern === 'function') {
-			return pattern(filePath);
-		}
-
-		throw new TypeError(`Unexpected matcher type ${pattern}.`);
-	};
-
-	// check for all matches to config.files
-	let filePathMatchesPattern = config.files.some(pattern => {
-		if (Array.isArray(pattern)) {
-			return pattern.every(match);
-		}
-
-		return match(pattern);
-	});
-
-	/*
-	 * If the file path matches the config.files patterns, then check to see
-	 * if there are any files to ignore.
-	 */
-	if (filePathMatchesPattern && config.ignores) {
-		filePathMatchesPattern = !shouldIgnorePath(config.ignores, filePath, relativeFilePath);
-	}
-
-	return filePathMatchesPattern;
-}
-
-/**
- * Ensures that a ConfigArray has been normalized.
- * @param {ConfigArray} configArray The ConfigArray to check. 
- * @returns {void}
- * @throws {Error} When the `ConfigArray` is not normalized.
- */
-function assertNormalized(configArray) {
-	// TODO: Throw more verbose error
-	if (!configArray.isNormalized()) {
-		throw new Error('ConfigArray must be normalized to perform this operation.');
-	}
-}
-
-/**
- * Ensures that config types are valid.
- * @param {Array<string>} extraConfigTypes The config types to check.
- * @returns {void}
- * @throws {Error} When the config types array is invalid.
- */
-function assertExtraConfigTypes(extraConfigTypes) {
-	if (extraConfigTypes.length > 2) {
-		throw new TypeError('configTypes must be an array with at most two items.');
-	}
-
-	for (const configType of extraConfigTypes) {
-		if (!CONFIG_TYPES.has(configType)) {
-			throw new TypeError(`Unexpected config type "${configType}" found. Expected one of: "object", "array", "function".`);
-		}
-	}
-}
-
-//------------------------------------------------------------------------------
-// Public Interface
-//------------------------------------------------------------------------------
-
-const ConfigArraySymbol = {
-	isNormalized: Symbol('isNormalized'),
-	configCache: Symbol('configCache'),
-	schema: Symbol('schema'),
-	finalizeConfig: Symbol('finalizeConfig'),
-	preprocessConfig: Symbol('preprocessConfig')
-};
-
-// used to store calculate data for faster lookup
-const dataCache = new WeakMap();
-
-/**
- * Represents an array of config objects and provides method for working with
- * those config objects.
- */
-class ConfigArray extends Array {
-
-	/**
-	 * Creates a new instance of ConfigArray.
-	 * @param {Iterable|Function|Object} configs An iterable yielding config
-	 *      objects, or a config function, or a config object.
-	 * @param {string} [options.basePath=""] The path of the config file
-	 * @param {boolean} [options.normalized=false] Flag indicating if the
-	 *      configs have already been normalized.
-	 * @param {Object} [options.schema] The additional schema 
-	 *      definitions to use for the ConfigArray schema.
-	 * @param {Array<string>} [options.configTypes] List of config types supported.
-	 */
-	constructor(configs, {
-		basePath = '',
-		normalized = false,
-		schema: customSchema,
-		extraConfigTypes = []
-	} = {}
-	) {
-		super();
-
-		/**
-		 * Tracks if the array has been normalized.
-		 * @property isNormalized
-		 * @type {boolean}
-		 * @private
-		 */
-		this[ConfigArraySymbol.isNormalized] = normalized;
-
-		/**
-		 * The schema used for validating and merging configs.
-		 * @property schema
-		 * @type ObjectSchema
-		 * @private
-		 */
-		this[ConfigArraySymbol.schema] = new objectSchema.ObjectSchema(
-			Object.assign({}, customSchema, baseSchema)
-		);
-
-		/**
-		 * The path of the config file that this array was loaded from.
-		 * This is used to calculate filename matches.
-		 * @property basePath
-		 * @type {string}
-		 */
-		this.basePath = basePath;
-
-		assertExtraConfigTypes(extraConfigTypes);
-
-		/**
-		 * The supported config types.
-		 * @property configTypes
-		 * @type {Array<string>}
-		 */
-		this.extraConfigTypes = Object.freeze([...extraConfigTypes]);
-
-		/**
-		 * A cache to store calculated configs for faster repeat lookup.
-		 * @property configCache
-		 * @type {Map<string, Object>}
-		 * @private
-		 */
-		this[ConfigArraySymbol.configCache] = new Map();
-
-		// init cache
-		dataCache.set(this, {
-			explicitMatches: new Map(),
-			directoryMatches: new Map(),
-			files: undefined,
-			ignores: undefined
-		});
-
-		// load the configs into this array
-		if (Array.isArray(configs)) {
-			this.push(...configs);
-		} else {
-			this.push(configs);
-		}
-
-	}
-
-	/**
-	 * Prevent normal array methods from creating a new `ConfigArray` instance.
-	 * This is to ensure that methods such as `slice()` won't try to create a 
-	 * new instance of `ConfigArray` behind the scenes as doing so may throw
-	 * an error due to the different constructor signature.
-	 * @returns {Function} The `Array` constructor.
-	 */
-	static get [Symbol.species]() {
-		return Array;
-	}
-
-	/**
-	 * Returns the `files` globs from every config object in the array.
-	 * This can be used to determine which files will be matched by a
-	 * config array or to use as a glob pattern when no patterns are provided
-	 * for a command line interface.
-	 * @returns {Array<string|Function>} An array of matchers.
-	 */
-	get files() {
-
-		assertNormalized(this);
-
-		// if this data has been cached, retrieve it
-		const cache = dataCache.get(this);
-
-		if (cache.files) {
-			return cache.files;
-		}
-
-		// otherwise calculate it
-
-		const result = [];
-
-		for (const config of this) {
-			if (config.files) {
-				config.files.forEach(filePattern => {
-					result.push(filePattern);
-				});
-			}
-		}
-
-		// store result
-		cache.files = result;
-		dataCache.set(this, cache);
-
-		return result;
-	}
-
-	/**
-	 * Returns ignore matchers that should always be ignored regardless of
-	 * the matching `files` fields in any configs. This is necessary to mimic
-	 * the behavior of things like .gitignore and .eslintignore, allowing a
-	 * globbing operation to be faster.
-	 * @returns {string[]} An array of string patterns and functions to be ignored.
-	 */
-	get ignores() {
-
-		assertNormalized(this);
-
-		// if this data has been cached, retrieve it
-		const cache = dataCache.get(this);
-
-		if (cache.ignores) {
-			return cache.ignores;
-		}
-
-		// otherwise calculate it
-
-		const result = [];
-
-		for (const config of this) {
-
-			/*
-			 * We only count ignores if there are no other keys in the object.
-			 * In this case, it acts list a globally ignored pattern. If there
-			 * are additional keys, then ignores act like exclusions.
-			 */
-			if (config.ignores && Object.keys(config).filter(key => !META_FIELDS.has(key)).length === 1) {
-				result.push(...config.ignores);
-			}
-		}
-
-		// store result
-		cache.ignores = result;
-		dataCache.set(this, cache);
-
-		return result;
-	}
-
-	/**
-	 * Indicates if the config array has been normalized.
-	 * @returns {boolean} True if the config array is normalized, false if not.
-	 */
-	isNormalized() {
-		return this[ConfigArraySymbol.isNormalized];
-	}
-
-	/**
-	 * Normalizes a config array by flattening embedded arrays and executing
-	 * config functions.
-	 * @param {ConfigContext} context The context object for config functions.
-	 * @returns {Promise<ConfigArray>} The current ConfigArray instance.
-	 */
-	async normalize(context = {}) {
-
-		if (!this.isNormalized()) {
-			const normalizedConfigs = await normalize(this, context, this.extraConfigTypes);
-			this.length = 0;
-			this.push(...normalizedConfigs.map(this[ConfigArraySymbol.preprocessConfig].bind(this)));
-			this.forEach(assertValidBaseConfig);
-			this[ConfigArraySymbol.isNormalized] = true;
-
-			// prevent further changes
-			Object.freeze(this);
-		}
-
-		return this;
-	}
-
-	/**
-	 * Normalizes a config array by flattening embedded arrays and executing
-	 * config functions.
-	 * @param {ConfigContext} context The context object for config functions.
-	 * @returns {ConfigArray} The current ConfigArray instance.
-	 */
-	normalizeSync(context = {}) {
-
-		if (!this.isNormalized()) {
-			const normalizedConfigs = normalizeSync(this, context, this.extraConfigTypes);
-			this.length = 0;
-			this.push(...normalizedConfigs.map(this[ConfigArraySymbol.preprocessConfig].bind(this)));
-			this.forEach(assertValidBaseConfig);
-			this[ConfigArraySymbol.isNormalized] = true;
-
-			// prevent further changes
-			Object.freeze(this);
-		}
-
-		return this;
-	}
-
-	/**
-	 * Finalizes the state of a config before being cached and returned by
-	 * `getConfig()`. Does nothing by default but is provided to be
-	 * overridden by subclasses as necessary.
-	 * @param {Object} config The config to finalize.
-	 * @returns {Object} The finalized config.
-	 */
-	[ConfigArraySymbol.finalizeConfig](config) {
-		return config;
-	}
-
-	/**
-	 * Preprocesses a config during the normalization process. This is the
-	 * method to override if you want to convert an array item before it is
-	 * validated for the first time. For example, if you want to replace a
-	 * string with an object, this is the method to override.
-	 * @param {Object} config The config to preprocess.
-	 * @returns {Object} The config to use in place of the argument.
-	 */
-	[ConfigArraySymbol.preprocessConfig](config) {
-		return config;
-	}
-
-	/**
-	 * Determines if a given file path explicitly matches a `files` entry
-	 * and also doesn't match an `ignores` entry. Configs that don't have
-	 * a `files` property are not considered an explicit match.
-	 * @param {string} filePath The complete path of a file to check.
-	 * @returns {boolean} True if the file path matches a `files` entry
-	 * 		or false if not.
-	 */
-	isExplicitMatch(filePath) {
-
-		assertNormalized(this);
-
-		const cache = dataCache.get(this);
-
-		// first check the cache to avoid duplicate work
-		let result = cache.explicitMatches.get(filePath);
-
-		if (typeof result == 'boolean') {
-			return result;
-		}
-
-		// TODO: Maybe move elsewhere? Maybe combine with getConfig() logic?
-		const relativeFilePath = path.relative(this.basePath, filePath);
-
-		if (shouldIgnorePath(this.ignores, filePath, relativeFilePath)) {
-			debug(`Ignoring ${filePath}`);
-
-			// cache and return result
-			cache.explicitMatches.set(filePath, false);
-			return false;
-		}
-
-		// filePath isn't automatically ignored, so try to find a match
-
-		for (const config of this) {
-
-			if (!config.files) {
-				continue;
-			}
-
-			if (pathMatches(filePath, this.basePath, config)) {
-				debug(`Matching config found for ${filePath}`);
-				cache.explicitMatches.set(filePath, true);
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Returns the config object for a given file path.
-	 * @param {string} filePath The complete path of a file to get a config for.
-	 * @returns {Object} The config object for this file.
-	 */
-	getConfig(filePath) {
-
-		assertNormalized(this);
-
-		const cache = this[ConfigArraySymbol.configCache];
-
-		// first check the cache for a filename match to avoid duplicate work
-		if (cache.has(filePath)) {
-			return cache.get(filePath);
-		}
-
-		let finalConfig;
-
-		// next check to see if the file should be ignored
-
-		// check if this should be ignored due to its directory
-		if (this.isDirectoryIgnored(path.dirname(filePath))) {
-			debug(`Ignoring ${filePath} based on directory pattern`);
-
-			// cache and return result - finalConfig is undefined at this point
-			cache.set(filePath, finalConfig);
-			return finalConfig;
-		}
-
-		// TODO: Maybe move elsewhere?
-		const relativeFilePath = path.relative(this.basePath, filePath);
-
-		if (shouldIgnorePath(this.ignores, filePath, relativeFilePath)) {
-			debug(`Ignoring ${filePath} based on file pattern`);
-
-			// cache and return result - finalConfig is undefined at this point
-			cache.set(filePath, finalConfig);
-			return finalConfig;
-		}
-
-		// filePath isn't automatically ignored, so try to construct config
-
-		const matchingConfigIndices = [];
-		let matchFound = false;
-		const universalPattern = /\/\*{1,2}$/;
-
-		this.forEach((config, index) => {
-
-			if (!config.files) {
-
-				if (!config.ignores) {
-					debug(`Anonymous universal config found for ${filePath}`);
-					matchingConfigIndices.push(index);
-					return;
-				}
-
-				if (pathMatchesIgnores(filePath, this.basePath, config)) {
-					debug(`Matching config found for ${filePath} (based on ignores: ${config.ignores})`);
-					matchingConfigIndices.push(index);
-					return;
-				}
-				
-				debug(`Skipped config found for ${filePath} (based on ignores: ${config.ignores})`);
-				return;
-			}
-
-			/*
-			 * If a config has a files pattern ending in /** or /*, and the
-			 * filePath only matches those patterns, then the config is only
-			 * applied if there is another config where the filePath matches
-			 * a file with a specific extensions such as *.js.
-			 */
-
-			const universalFiles = config.files.filter(
-				pattern => universalPattern.test(pattern)
-			);
-
-			// universal patterns were found so we need to check the config twice
-			if (universalFiles.length) {
-
-				debug('Universal files patterns found. Checking carefully.');
-
-				const nonUniversalFiles = config.files.filter(
-					pattern => !universalPattern.test(pattern)
-				);
-
-				// check that the config matches without the non-universal files first
-				if (
-					nonUniversalFiles.length && 
-					pathMatches(
-						filePath, this.basePath,
-						{ files: nonUniversalFiles, ignores: config.ignores }
-					)
-				) {
-					debug(`Matching config found for ${filePath}`);
-					matchingConfigIndices.push(index);
-					matchFound = true;
-					return;
-				}
-
-				// if there wasn't a match then check if it matches with universal files
-				if (
-					universalFiles.length &&
-					pathMatches(
-						filePath, this.basePath,
-						{ files: universalFiles, ignores: config.ignores }
-					)
-				) {
-					debug(`Matching config found for ${filePath}`);
-					matchingConfigIndices.push(index);
-					return;
-				}
-
-				// if we make here, then there was no match
-				return;
-			}
-
-			// the normal case
-			if (pathMatches(filePath, this.basePath, config)) {
-				debug(`Matching config found for ${filePath}`);
-				matchingConfigIndices.push(index);
-				matchFound = true;
-				return;
-			}
-
-		});
-
-		// if matching both files and ignores, there will be no config to create
-		if (!matchFound) {
-			debug(`No matching configs found for ${filePath}`);
-
-			// cache and return result - finalConfig is undefined at this point
-			cache.set(filePath, finalConfig);
-			return finalConfig;
-		}
-
-		// check to see if there is a config cached by indices
-		finalConfig = cache.get(matchingConfigIndices.toString());
-
-		if (finalConfig) {
-
-			// also store for filename for faster lookup next time
-			cache.set(filePath, finalConfig);
-
-			return finalConfig;
-		}
-
-		// otherwise construct the config
-
-		finalConfig = matchingConfigIndices.reduce((result, index) => {
-			try {
-				return this[ConfigArraySymbol.schema].merge(result, this[index]);
-			} catch (validationError) {
-				rethrowConfigError(this[index], index, { cause: validationError});
-			}
-		}, {}, this);
-
-		finalConfig = this[ConfigArraySymbol.finalizeConfig](finalConfig);
-
-		cache.set(filePath, finalConfig);
-		cache.set(matchingConfigIndices.toString(), finalConfig);
-
-		return finalConfig;
-	}
-
-	/**
-	 * Determines if the given filepath is ignored based on the configs.
-	 * @param {string} filePath The complete path of a file to check.
-	 * @returns {boolean} True if the path is ignored, false if not.
-	 * @deprecated Use `isFileIgnored` instead.
-	 */
-	isIgnored(filePath) {
-		return this.isFileIgnored(filePath);
-	}
-
-	/**
-	 * Determines if the given filepath is ignored based on the configs.
-	 * @param {string} filePath The complete path of a file to check.
-	 * @returns {boolean} True if the path is ignored, false if not.
-	 */
-	isFileIgnored(filePath) {
-		return this.getConfig(filePath) === undefined;
-	}
-
-	/**
-	 * Determines if the given directory is ignored based on the configs.
-	 * This checks only default `ignores` that don't have `files` in the 
-	 * same config. A pattern such as `/foo` be considered to ignore the directory
-	 * while a pattern such as `/foo/**` is not considered to ignore the
-	 * directory because it is matching files.
-	 * @param {string} directoryPath The complete path of a directory to check.
-	 * @returns {boolean} True if the directory is ignored, false if not. Will
-	 * 		return true for any directory that is not inside of `basePath`.
-	 * @throws {Error} When the `ConfigArray` is not normalized.
-	 */
-	isDirectoryIgnored(directoryPath) {
-
-		assertNormalized(this);
-
-		const relativeDirectoryPath = path.relative(this.basePath, directoryPath)
-			.replace(/\\/g, '/');
-
-		if (relativeDirectoryPath.startsWith('..')) {
-			return true;
-		}
-
-		// first check the cache
-		const cache = dataCache.get(this).directoryMatches;
-
-		if (cache.has(relativeDirectoryPath)) {
-			return cache.get(relativeDirectoryPath);
-		}
-
-		const directoryParts = relativeDirectoryPath.split('/');
-		let relativeDirectoryToCheck = '';
-		let result = false;
-
-		/*
-		 * In order to get the correct gitignore-style ignores, where an
-		 * ignored parent directory cannot have any descendants unignored,
-		 * we need to check every directory starting at the parent all
-		 * the way down to the actual requested directory.
-		 * 
-		 * We aggressively cache all of this info to make sure we don't
-		 * have to recalculate everything for every call.
-		 */
-		do {
-
-			relativeDirectoryToCheck += directoryParts.shift() + '/';
-
-			result = shouldIgnorePath(
-				this.ignores,
-				path.join(this.basePath, relativeDirectoryToCheck),
-				relativeDirectoryToCheck
-			);
-
-			cache.set(relativeDirectoryToCheck, result);
-
-		} while (!result && directoryParts.length);
-
-		// also cache the result for the requested path
-		cache.set(relativeDirectoryPath, result);
-
-		return result;
-	}
-
-}
-
-exports.ConfigArray = ConfigArray;
-exports.ConfigArraySymbol = ConfigArraySymbol;