Deployed the page to Github Pages.

2024-11-03 21:30:09 -05:00 · 2024-11-03 21:30:09 -05:00 · 2c89899458
commit 2c89899458
parent 1d79754e93
62797 changed files with 6551425 additions and 15279 deletions
--- a/node_modules/globby/index.d.ts
+++ b/node_modules/globby/index.d.ts
@ -0,0 +1,207 @@
+import type FastGlob from 'fast-glob';
+
+export type GlobEntry = FastGlob.Entry;
+
+export type GlobTask = {
+	readonly patterns: string[];
+	readonly options: Options;
+};
+
+export type ExpandDirectoriesOption =
+	| boolean
+	| readonly string[]
+	| {files?: readonly string[]; extensions?: readonly string[]};
+
+type FastGlobOptionsWithoutCwd = Omit<FastGlob.Options, 'cwd'>;
+
+export type Options = {
+	/**
+	If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `Object` with `files` and `extensions` like in the example below.
+
+	Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
+
+	@default true
+
+	@example
+	```
+	import {globby} from 'globby';
+
+	const paths = await globby('images', {
+		expandDirectories: {
+			files: ['cat', 'unicorn', '*.jpg'],
+			extensions: ['png']
+		}
+	});
+
+	console.log(paths);
+	//=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
+	```
+	*/
+	readonly expandDirectories?: ExpandDirectoriesOption;
+
+	/**
+	Respect ignore patterns in `.gitignore` files that apply to the globbed files.
+
+	@default false
+	*/
+	readonly gitignore?: boolean;
+
+	/**
+	Glob patterns to look for ignore files, which are then used to ignore globbed files.
+
+	This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
+
+	@default undefined
+	*/
+	readonly ignoreFiles?: string | readonly string[];
+
+	/**
+	The current working directory in which to search.
+
+	@default process.cwd()
+	*/
+	readonly cwd?: URL | string;
+} & FastGlobOptionsWithoutCwd;
+
+export type GitignoreOptions = {
+	readonly cwd?: URL | string;
+};
+
+export type GlobbyFilterFunction = (path: URL | string) => boolean;
+
+/**
+Find files and directories using glob patterns.
+
+Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+@returns The matching paths.
+
+@example
+```
+import {globby} from 'globby';
+
+const paths = await globby(['*', '!cake']);
+
+console.log(paths);
+//=> ['unicorn', 'rainbow']
+```
+*/
+export function globby(
+	patterns: string | readonly string[],
+	options: Options & {objectMode: true}
+): Promise<GlobEntry[]>;
+export function globby(
+	patterns: string | readonly string[],
+	options?: Options
+): Promise<string[]>;
+
+/**
+Find files and directories using glob patterns.
+
+Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+@returns The matching paths.
+*/
+export function globbySync(
+	patterns: string | readonly string[],
+	options: Options & {objectMode: true}
+): GlobEntry[];
+export function globbySync(
+	patterns: string | readonly string[],
+	options?: Options
+): string[];
+
+/**
+Find files and directories using glob patterns.
+
+Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+@returns The stream of matching paths.
+
+@example
+```
+import {globbyStream} from 'globby';
+
+for await (const path of globbyStream('*.tmp')) {
+	console.log(path);
+}
+```
+*/
+export function globbyStream(
+	patterns: string | readonly string[],
+	options?: Options
+): NodeJS.ReadableStream;
+
+/**
+Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
+
+@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones in this package.
+@returns An object in the format `{pattern: string, options: object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+*/
+export function generateGlobTasks(
+	patterns: string | readonly string[],
+	options?: Options
+): Promise<GlobTask[]>;
+
+/**
+@see generateGlobTasks
+
+@returns An object in the format `{pattern: string, options: object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+*/
+export function generateGlobTasksSync(
+	patterns: string | readonly string[],
+	options?: Options
+): GlobTask[];
+
+/**
+Note that the options affect the results.
+
+This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).
+
+@param patterns - See the supported [glob patterns](https://github.com/sindresorhus/globby#globbing-patterns).
+@param options - See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3).
+@returns Whether there are any special glob characters in the `patterns`.
+*/
+export function isDynamicPattern(
+	patterns: string | readonly string[],
+	options?: FastGlobOptionsWithoutCwd & {
+		/**
+		The current working directory in which to search.
+
+		@default process.cwd()
+		*/
+		readonly cwd?: URL | string;
+	}
+): boolean;
+
+/**
+`.gitignore` files matched by the ignore config are not used for the resulting filter function.
+
+@returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
+
+@example
+```
+import {isGitIgnored} from 'globby';
+
+const isIgnored = await isGitIgnored();
+
+console.log(isIgnored('some/file'));
+```
+*/
+export function isGitIgnored(options?: GitignoreOptions): Promise<GlobbyFilterFunction>;
+
+/**
+@see isGitIgnored
+
+@returns A filter function indicating whether a given path is ignored via a `.gitignore` file.
+*/
+export function isGitIgnoredSync(options?: GitignoreOptions): GlobbyFilterFunction;
+
+export function convertPathToPattern(source: string): FastGlob.Pattern;
--- a/node_modules/globby/index.js
+++ b/node_modules/globby/index.js
@ -0,0 +1,264 @@
+import process from 'node:process';
+import fs from 'node:fs';
+import nodePath from 'node:path';
+import mergeStreams from '@sindresorhus/merge-streams';
+import fastGlob from 'fast-glob';
+import {isDirectory, isDirectorySync} from 'path-type';
+import {toPath} from 'unicorn-magic';
+import {
+	GITIGNORE_FILES_PATTERN,
+	isIgnoredByIgnoreFiles,
+	isIgnoredByIgnoreFilesSync,
+} from './ignore.js';
+import {isNegativePattern} from './utilities.js';
+
+const assertPatternsInput = patterns => {
+	if (patterns.some(pattern => typeof pattern !== 'string')) {
+		throw new TypeError('Patterns must be a string or an array of strings');
+	}
+};
+
+const normalizePathForDirectoryGlob = (filePath, cwd) => {
+	const path = isNegativePattern(filePath) ? filePath.slice(1) : filePath;
+	return nodePath.isAbsolute(path) ? path : nodePath.join(cwd, path);
+};
+
+const getDirectoryGlob = ({directoryPath, files, extensions}) => {
+	const extensionGlob = extensions?.length > 0 ? `.${extensions.length > 1 ? `{${extensions.join(',')}}` : extensions[0]}` : '';
+	return files
+		? files.map(file => nodePath.posix.join(directoryPath, `**/${nodePath.extname(file) ? file : `${file}${extensionGlob}`}`))
+		: [nodePath.posix.join(directoryPath, `**${extensionGlob ? `/*${extensionGlob}` : ''}`)];
+};
+
+const directoryToGlob = async (directoryPaths, {
+	cwd = process.cwd(),
+	files,
+	extensions,
+} = {}) => {
+	const globs = await Promise.all(directoryPaths.map(async directoryPath =>
+		(await isDirectory(normalizePathForDirectoryGlob(directoryPath, cwd))) ? getDirectoryGlob({directoryPath, files, extensions}) : directoryPath),
+	);
+
+	return globs.flat();
+};
+
+const directoryToGlobSync = (directoryPaths, {
+	cwd = process.cwd(),
+	files,
+	extensions,
+} = {}) => directoryPaths.flatMap(directoryPath => isDirectorySync(normalizePathForDirectoryGlob(directoryPath, cwd)) ? getDirectoryGlob({directoryPath, files, extensions}) : directoryPath);
+
+const toPatternsArray = patterns => {
+	patterns = [...new Set([patterns].flat())];
+	assertPatternsInput(patterns);
+	return patterns;
+};
+
+const checkCwdOption = cwd => {
+	if (!cwd) {
+		return;
+	}
+
+	let stat;
+	try {
+		stat = fs.statSync(cwd);
+	} catch {
+		return;
+	}
+
+	if (!stat.isDirectory()) {
+		throw new Error('The `cwd` option must be a path to a directory');
+	}
+};
+
+const normalizeOptions = (options = {}) => {
+	options = {
+		...options,
+		ignore: options.ignore ?? [],
+		expandDirectories: options.expandDirectories ?? true,
+		cwd: toPath(options.cwd),
+	};
+
+	checkCwdOption(options.cwd);
+
+	return options;
+};
+
+const normalizeArguments = function_ => async (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions(options));
+const normalizeArgumentsSync = function_ => (patterns, options) => function_(toPatternsArray(patterns), normalizeOptions(options));
+
+const getIgnoreFilesPatterns = options => {
+	const {ignoreFiles, gitignore} = options;
+
+	const patterns = ignoreFiles ? toPatternsArray(ignoreFiles) : [];
+	if (gitignore) {
+		patterns.push(GITIGNORE_FILES_PATTERN);
+	}
+
+	return patterns;
+};
+
+const getFilter = async options => {
+	const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+	return createFilterFunction(
+		ignoreFilesPatterns.length > 0 && await isIgnoredByIgnoreFiles(ignoreFilesPatterns, options),
+	);
+};
+
+const getFilterSync = options => {
+	const ignoreFilesPatterns = getIgnoreFilesPatterns(options);
+	return createFilterFunction(
+		ignoreFilesPatterns.length > 0 && isIgnoredByIgnoreFilesSync(ignoreFilesPatterns, options),
+	);
+};
+
+const createFilterFunction = isIgnored => {
+	const seen = new Set();
+
+	return fastGlobResult => {
+		const pathKey = nodePath.normalize(fastGlobResult.path ?? fastGlobResult);
+
+		if (seen.has(pathKey) || (isIgnored && isIgnored(pathKey))) {
+			return false;
+		}
+
+		seen.add(pathKey);
+
+		return true;
+	};
+};
+
+const unionFastGlobResults = (results, filter) => results.flat().filter(fastGlobResult => filter(fastGlobResult));
+
+const convertNegativePatterns = (patterns, options) => {
+	const tasks = [];
+
+	while (patterns.length > 0) {
+		const index = patterns.findIndex(pattern => isNegativePattern(pattern));
+
+		if (index === -1) {
+			tasks.push({patterns, options});
+			break;
+		}
+
+		const ignorePattern = patterns[index].slice(1);
+
+		for (const task of tasks) {
+			task.options.ignore.push(ignorePattern);
+		}
+
+		if (index !== 0) {
+			tasks.push({
+				patterns: patterns.slice(0, index),
+				options: {
+					...options,
+					ignore: [
+						...options.ignore,
+						ignorePattern,
+					],
+				},
+			});
+		}
+
+		patterns = patterns.slice(index + 1);
+	}
+
+	return tasks;
+};
+
+const normalizeExpandDirectoriesOption = (options, cwd) => ({
+	...(cwd ? {cwd} : {}),
+	...(Array.isArray(options) ? {files: options} : options),
+});
+
+const generateTasks = async (patterns, options) => {
+	const globTasks = convertNegativePatterns(patterns, options);
+
+	const {cwd, expandDirectories} = options;
+
+	if (!expandDirectories) {
+		return globTasks;
+	}
+
+	const directoryToGlobOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
+
+	return Promise.all(
+		globTasks.map(async task => {
+			let {patterns, options} = task;
+
+			[
+				patterns,
+				options.ignore,
+			] = await Promise.all([
+				directoryToGlob(patterns, directoryToGlobOptions),
+				directoryToGlob(options.ignore, {cwd}),
+			]);
+
+			return {patterns, options};
+		}),
+	);
+};
+
+const generateTasksSync = (patterns, options) => {
+	const globTasks = convertNegativePatterns(patterns, options);
+	const {cwd, expandDirectories} = options;
+
+	if (!expandDirectories) {
+		return globTasks;
+	}
+
+	const directoryToGlobSyncOptions = normalizeExpandDirectoriesOption(expandDirectories, cwd);
+
+	return globTasks.map(task => {
+		let {patterns, options} = task;
+		patterns = directoryToGlobSync(patterns, directoryToGlobSyncOptions);
+		options.ignore = directoryToGlobSync(options.ignore, {cwd});
+		return {patterns, options};
+	});
+};
+
+export const globby = normalizeArguments(async (patterns, options) => {
+	const [
+		tasks,
+		filter,
+	] = await Promise.all([
+		generateTasks(patterns, options),
+		getFilter(options),
+	]);
+
+	const results = await Promise.all(tasks.map(task => fastGlob(task.patterns, task.options)));
+	return unionFastGlobResults(results, filter);
+});
+
+export const globbySync = normalizeArgumentsSync((patterns, options) => {
+	const tasks = generateTasksSync(patterns, options);
+	const filter = getFilterSync(options);
+	const results = tasks.map(task => fastGlob.sync(task.patterns, task.options));
+	return unionFastGlobResults(results, filter);
+});
+
+export const globbyStream = normalizeArgumentsSync((patterns, options) => {
+	const tasks = generateTasksSync(patterns, options);
+	const filter = getFilterSync(options);
+	const streams = tasks.map(task => fastGlob.stream(task.patterns, task.options));
+	const stream = mergeStreams(streams).filter(fastGlobResult => filter(fastGlobResult));
+
+	// TODO: Make it return a web stream at some point.
+	// return Readable.toWeb(stream);
+
+	return stream;
+});
+
+export const isDynamicPattern = normalizeArgumentsSync(
+	(patterns, options) => patterns.some(pattern => fastGlob.isDynamicPattern(pattern, options)),
+);
+
+export const generateGlobTasks = normalizeArguments(generateTasks);
+export const generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
+
+export {
+	isGitIgnored,
+	isGitIgnoredSync,
+} from './ignore.js';
+
+export const {convertPathToPattern} = fastGlob;
--- a/node_modules/globby/license
+++ b/node_modules/globby/license
@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/node_modules/globby/package.json
+++ b/node_modules/globby/package.json
@ -0,0 +1,94 @@
+{
+	"name": "globby",
+	"version": "14.0.2",
+	"description": "User-friendly glob matching",
+	"license": "MIT",
+	"repository": "sindresorhus/globby",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"email": "sindresorhus@gmail.com",
+		"name": "Sindre Sorhus",
+		"url": "https://sindresorhus.com"
+	},
+	"type": "module",
+	"exports": {
+		"types": "./index.d.ts",
+		"default": "./index.js"
+	},
+	"sideEffects": false,
+	"engines": {
+		"node": ">=18"
+	},
+	"scripts": {
+		"bench": "npm update @globby/main-branch glob-stream fast-glob && node bench.js",
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts",
+		"ignore.js",
+		"utilities.js"
+	],
+	"keywords": [
+		"all",
+		"array",
+		"directories",
+		"expand",
+		"files",
+		"filesystem",
+		"filter",
+		"find",
+		"fnmatch",
+		"folders",
+		"fs",
+		"glob",
+		"globbing",
+		"globs",
+		"gulpfriendly",
+		"match",
+		"matcher",
+		"minimatch",
+		"multi",
+		"multiple",
+		"paths",
+		"pattern",
+		"patterns",
+		"traverse",
+		"util",
+		"utility",
+		"wildcard",
+		"wildcards",
+		"promise",
+		"gitignore",
+		"git"
+	],
+	"dependencies": {
+		"@sindresorhus/merge-streams": "^2.1.0",
+		"fast-glob": "^3.3.2",
+		"ignore": "^5.2.4",
+		"path-type": "^5.0.0",
+		"slash": "^5.1.0",
+		"unicorn-magic": "^0.1.0"
+	},
+	"devDependencies": {
+		"@globby/main-branch": "sindresorhus/globby#main",
+		"@types/node": "^20.9.0",
+		"ava": "^5.3.1",
+		"benchmark": "2.1.4",
+		"glob-stream": "^8.0.0",
+		"tempy": "^3.1.0",
+		"tsd": "^0.30.4",
+		"xo": "^0.57.0"
+	},
+	"xo": {
+		"ignores": [
+			"fixtures"
+		]
+	},
+	"ava": {
+		"files": [
+			"!tests/utilities.js"
+		],
+		"workerThreads": false
+	}
+}
--- a/node_modules/globby/readme.md
+++ b/node_modules/globby/readme.md
@ -0,0 +1,177 @@
+# globby
+
+> User-friendly glob matching
+
+Based on [`fast-glob`](https://github.com/mrmlnc/fast-glob) but adds a bunch of useful features.
+
+## Features
+
+- Promise API
+- Multiple patterns
+- Negated patterns: `['foo*', '!foobar']`
+- Expands directories: `foo` → `foo/**/*`
+- Supports `.gitignore` and similar ignore config files
+- Supports `URL` as `cwd`
+
+## Install
+
+```sh
+npm install globby
+```
+
+## Usage
+
+```
+├── unicorn
+├── cake
+└── rainbow
+```
+
+```js
+import {globby} from 'globby';
+
+const paths = await globby(['*', '!cake']);
+
+console.log(paths);
+//=> ['unicorn', 'rainbow']
+```
+
+## API
+
+Note that glob patterns can only contain forward-slashes, not backward-slashes, so if you want to construct a glob pattern from path components, you need to use `path.posix.join()` instead of `path.join()`.
+
+### globby(patterns, options?)
+
+Returns a `Promise<string[]>` of matching paths.
+
+#### patterns
+
+Type: `string | string[]`
+
+See supported `minimatch` [patterns](https://github.com/isaacs/minimatch#usage).
+
+#### options
+
+Type: `object`
+
+See the [`fast-glob` options](https://github.com/mrmlnc/fast-glob#options-3) in addition to the ones below.
+
+##### expandDirectories
+
+Type: `boolean | string[] | object`\
+Default: `true`
+
+If set to `true`, `globby` will automatically glob directories for you. If you define an `Array` it will only glob files that matches the patterns inside the `Array`. You can also define an `object` with `files` and `extensions` like below:
+
+```js
+import {globby} from 'globby';
+
+const paths = await globby('images', {
+	expandDirectories: {
+		files: ['cat', 'unicorn', '*.jpg'],
+		extensions: ['png']
+	}
+});
+
+console.log(paths);
+//=> ['cat.png', 'unicorn.png', 'cow.jpg', 'rainbow.jpg']
+```
+
+Note that if you set this option to `false`, you won't get back matched directories unless you set `onlyFiles: false`.
+
+##### gitignore
+
+Type: `boolean`\
+Default: `false`
+
+Respect ignore patterns in `.gitignore` files that apply to the globbed files.
+
+##### ignoreFiles
+
+Type: `string | string[]`\
+Default: `undefined`
+
+Glob patterns to look for ignore files, which are then used to ignore globbed files.
+
+This is a more generic form of the `gitignore` option, allowing you to find ignore files with a [compatible syntax](http://git-scm.com/docs/gitignore). For instance, this works with Babel's `.babelignore`, Prettier's `.prettierignore`, or ESLint's `.eslintignore` files.
+
+### globbySync(patterns, options?)
+
+Returns `string[]` of matching paths.
+
+### globbyStream(patterns, options?)
+
+Returns a [`stream.Readable`](https://nodejs.org/api/stream.html#stream_readable_streams) of matching paths.
+
+For example, loop over glob matches in a [`for await...of` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of) like this:
+
+```js
+import {globbyStream} from 'globby';
+
+for await (const path of globbyStream('*.tmp')) {
+	console.log(path);
+}
+```
+
+### convertPathToPattern(path)
+
+Convert a path to a pattern. [Learn more.](https://github.com/mrmlnc/fast-glob#convertpathtopatternpath)
+
+### generateGlobTasks(patterns, options?)
+
+Returns an `Promise<object[]>` in the format `{patterns: string[], options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+
+Note that you should avoid running the same tasks multiple times as they contain a file system cache. Instead, run this method each time to ensure file system changes are taken into consideration.
+
+### generateGlobTasksSync(patterns, options?)
+
+Returns an `object[]` in the format `{patterns: string[], options: Object}`, which can be passed as arguments to [`fast-glob`](https://github.com/mrmlnc/fast-glob). This is useful for other globbing-related packages.
+
+Takes the same arguments as `generateGlobTasks`.
+
+### isDynamicPattern(patterns, options?)
+
+Returns a `boolean` of whether there are any special glob characters in the `patterns`.
+
+Note that the options affect the results.
+
+This function is backed by [`fast-glob`](https://github.com/mrmlnc/fast-glob#isdynamicpatternpattern-options).
+
+### isGitIgnored(options?)
+
+Returns a `Promise<(path: URL | string) => boolean>` indicating whether a given path is ignored via a `.gitignore` file.
+
+Takes `cwd?: URL | string` as options.
+
+```js
+import {isGitIgnored} from 'globby';
+
+const isIgnored = await isGitIgnored();
+
+console.log(isIgnored('some/file'));
+```
+
+### isGitIgnoredSync(options?)
+
+Returns a `(path: URL | string) => boolean` indicating whether a given path is ignored via a `.gitignore` file.
+
+Takes `cwd?: URL | string` as options.
+
+## Globbing patterns
+
+Just a quick overview.
+
+- `*` matches any number of characters, but not `/`
+- `?` matches a single character, but not `/`
+- `**` matches any number of characters, including `/`, as long as it's the only thing in a path part
+- `{}` allows for a comma-separated list of "or" expressions
+- `!` at the beginning of a pattern will negate the match
+
+[Various patterns and expected matches.](https://github.com/sindresorhus/multimatch/blob/main/test/test.js)
+
+## Related
+
+- [multimatch](https://github.com/sindresorhus/multimatch) - Match against a list instead of the filesystem
+- [matcher](https://github.com/sindresorhus/matcher) - Simple wildcard matching
+- [del](https://github.com/sindresorhus/del) - Delete files and directories
+- [make-dir](https://github.com/sindresorhus/make-dir) - Make a directory and its parents if needed