wiki-plugin-allyabase 0.0.2 → 0.0.3

package/test/node_modules/glob/dist/esm/bin.mjs

@@ -1,270 +0,0 @@
-#!/usr/bin/env node
-import { foregroundChild } from 'foreground-child';
-import { existsSync } from 'fs';
-import { jack } from 'jackspeak';
-import { loadPackageJson } from 'package-json-from-dist';
-import { join } from 'path';
-import { globStream } from './index.js';
-const { version } = loadPackageJson(import.meta.url, '../package.json');
-const j = jack({
-    usage: 'glob [options] [<pattern> [<pattern> ...]]',
-})
-    .description(`
-    Glob v${version}
-
-    Expand the positional glob expression arguments into any matching file
-    system paths found.
-  `)
-    .opt({
-    cmd: {
-        short: 'c',
-        hint: 'command',
-        description: `Run the command provided, passing the glob expression
-                    matches as arguments.`,
-    },
-})
-    .opt({
-    default: {
-        short: 'p',
-        hint: 'pattern',
-        description: `If no positional arguments are provided, glob will use
-                    this pattern`,
-    },
-})
-    .flag({
-    all: {
-        short: 'A',
-        description: `By default, the glob cli command will not expand any
-                    arguments that are an exact match to a file on disk.
-
-                    This prevents double-expanding, in case the shell expands
-                    an argument whose filename is a glob expression.
-
-                    For example, if 'app/*.ts' would match 'app/[id].ts', then
-                    on Windows powershell or cmd.exe, 'glob app/*.ts' will
-                    expand to 'app/[id].ts', as expected. However, in posix
-                    shells such as bash or zsh, the shell will first expand
-                    'app/*.ts' to a list of filenames. Then glob will look
-                    for a file matching 'app/[id].ts' (ie, 'app/i.ts' or
-                    'app/d.ts'), which is unexpected.
-
-                    Setting '--all' prevents this behavior, causing glob
-                    to treat ALL patterns as glob expressions to be expanded,
-                    even if they are an exact match to a file on disk.
-
-                    When setting this option, be sure to enquote arguments
-                    so that the shell will not expand them prior to passing
-                    them to the glob command process.
-      `,
-    },
-    absolute: {
-        short: 'a',
-        description: 'Expand to absolute paths',
-    },
-    'dot-relative': {
-        short: 'd',
-        description: `Prepend './' on relative matches`,
-    },
-    mark: {
-        short: 'm',
-        description: `Append a / on any directories matched`,
-    },
-    posix: {
-        short: 'x',
-        description: `Always resolve to posix style paths, using '/' as the
-                    directory separator, even on Windows. Drive letter
-                    absolute matches on Windows will be expanded to their
-                    full resolved UNC maths, eg instead of 'C:\\foo\\bar',
-                    it will expand to '//?/C:/foo/bar'.
-      `,
-    },
-    follow: {
-        short: 'f',
-        description: `Follow symlinked directories when expanding '**'`,
-    },
-    realpath: {
-        short: 'R',
-        description: `Call 'fs.realpath' on all of the results. In the case
-                    of an entry that cannot be resolved, the entry is
-                    omitted. This incurs a slight performance penalty, of
-                    course, because of the added system calls.`,
-    },
-    stat: {
-        short: 's',
-        description: `Call 'fs.lstat' on all entries, whether required or not
-                    to determine if it's a valid match.`,
-    },
-    'match-base': {
-        short: 'b',
-        description: `Perform a basename-only match if the pattern does not
-                    contain any slash characters. That is, '*.js' would be
-                    treated as equivalent to '**/*.js', matching js files
-                    in all directories.
-      `,
-    },
-    dot: {
-        description: `Allow patterns to match files/directories that start
-                    with '.', even if the pattern does not start with '.'
-      `,
-    },
-    nobrace: {
-        description: 'Do not expand {...} patterns',
-    },
-    nocase: {
-        description: `Perform a case-insensitive match. This defaults to
-                    'true' on macOS and Windows platforms, and false on
-                    all others.
-
-                    Note: 'nocase' should only be explicitly set when it is
-                    known that the filesystem's case sensitivity differs
-                    from the platform default. If set 'true' on
-                    case-insensitive file systems, then the walk may return
-                    more or less results than expected.
-      `,
-    },
-    nodir: {
-        description: `Do not match directories, only files.
-
-                    Note: to *only* match directories, append a '/' at the
-                    end of the pattern.
-      `,
-    },
-    noext: {
-        description: `Do not expand extglob patterns, such as '+(a|b)'`,
-    },
-    noglobstar: {
-        description: `Do not expand '**' against multiple path portions.
-                    Ie, treat it as a normal '*' instead.`,
-    },
-    'windows-path-no-escape': {
-        description: `Use '\\' as a path separator *only*, and *never* as an
-                    escape character. If set, all '\\' characters are
-                    replaced with '/' in the pattern.`,
-    },
-})
-    .num({
-    'max-depth': {
-        short: 'D',
-        description: `Maximum depth to traverse from the current
-                    working directory`,
-    },
-})
-    .opt({
-    cwd: {
-        short: 'C',
-        description: 'Current working directory to execute/match in',
-        default: process.cwd(),
-    },
-    root: {
-        short: 'r',
-        description: `A string path resolved against the 'cwd', which is
-                    used as the starting point for absolute patterns that
-                    start with '/' (but not drive letters or UNC paths
-                    on Windows).
-
-                    Note that this *doesn't* necessarily limit the walk to
-                    the 'root' directory, and doesn't affect the cwd
-                    starting point for non-absolute patterns. A pattern
-                    containing '..' will still be able to traverse out of
-                    the root directory, if it is not an actual root directory
-                    on the filesystem, and any non-absolute patterns will
-                    still be matched in the 'cwd'.
-
-                    To start absolute and non-absolute patterns in the same
-                    path, you can use '--root=' to set it to the empty
-                    string. However, be aware that on Windows systems, a
-                    pattern like 'x:/*' or '//host/share/*' will *always*
-                    start in the 'x:/' or '//host/share/' directory,
-                    regardless of the --root setting.
-      `,
-    },
-    platform: {
-        description: `Defaults to the value of 'process.platform' if
-                    available, or 'linux' if not. Setting --platform=win32
-                    on non-Windows systems may cause strange behavior!`,
-        validOptions: [
-            'aix',
-            'android',
-            'darwin',
-            'freebsd',
-            'haiku',
-            'linux',
-            'openbsd',
-            'sunos',
-            'win32',
-            'cygwin',
-            'netbsd',
-        ],
-    },
-})
-    .optList({
-    ignore: {
-        short: 'i',
-        description: `Glob patterns to ignore`,
-    },
-})
-    .flag({
-    debug: {
-        short: 'v',
-        description: `Output a huge amount of noisy debug information about
-                    patterns as they are parsed and used to match files.`,
-    },
-})
-    .flag({
-    help: {
-        short: 'h',
-        description: 'Show this usage information',
-    },
-});
-try {
-    const { positionals, values } = j.parse();
-    if (values.help) {
-        console.log(j.usage());
-        process.exit(0);
-    }
-    if (positionals.length === 0 && !values.default)
-        throw 'No patterns provided';
-    if (positionals.length === 0 && values.default)
-        positionals.push(values.default);
-    const patterns = values.all ? positionals : positionals.filter(p => !existsSync(p));
-    const matches = values.all ?
-        []
-        : positionals.filter(p => existsSync(p)).map(p => join(p));
-    const stream = globStream(patterns, {
-        absolute: values.absolute,
-        cwd: values.cwd,
-        dot: values.dot,
-        dotRelative: values['dot-relative'],
-        follow: values.follow,
-        ignore: values.ignore,
-        mark: values.mark,
-        matchBase: values['match-base'],
-        maxDepth: values['max-depth'],
-        nobrace: values.nobrace,
-        nocase: values.nocase,
-        nodir: values.nodir,
-        noext: values.noext,
-        noglobstar: values.noglobstar,
-        platform: values.platform,
-        realpath: values.realpath,
-        root: values.root,
-        stat: values.stat,
-        debug: values.debug,
-        posix: values.posix,
-    });
-    const cmd = values.cmd;
-    if (!cmd) {
-        matches.forEach(m => console.log(m));
-        stream.on('data', f => console.log(f));
-    }
-    else {
-        stream.on('data', f => matches.push(f));
-        stream.on('end', () => foregroundChild(cmd, matches, { shell: true }));
-    }
-}
-catch (e) {
-    console.error(j.usage());
-    console.error(e instanceof Error ? e.message : String(e));
-    process.exit(1);
-}
-//# sourceMappingURL=bin.mjs.map

package/test/node_modules/glob/dist/esm/bin.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.mjs","sourceRoot":"","sources":["../../src/bin.mts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport { foregroundChild } from 'foreground-child'\nimport { existsSync } from 'fs'\nimport { jack } from 'jackspeak'\nimport { loadPackageJson } from 'package-json-from-dist'\nimport { join } from 'path'\nimport { globStream } from './index.js'\n\nconst { version } = loadPackageJson(import.meta.url, '../package.json')\n\nconst j = jack({\n  usage: 'glob [options] [<pattern> [<pattern> ...]]',\n})\n  .description(\n    `\n    Glob v${version}\n\n    Expand the positional glob expression arguments into any matching file\n    system paths found.\n  `,\n  )\n  .opt({\n    cmd: {\n      short: 'c',\n      hint: 'command',\n      description: `Run the command provided, passing the glob expression\n                    matches as arguments.`,\n    },\n  })\n  .opt({\n    default: {\n      short: 'p',\n      hint: 'pattern',\n      description: `If no positional arguments are provided, glob will use\n                    this pattern`,\n    },\n  })\n  .flag({\n    all: {\n      short: 'A',\n      description: `By default, the glob cli command will not expand any\n                    arguments that are an exact match to a file on disk.\n\n                    This prevents double-expanding, in case the shell expands\n                    an argument whose filename is a glob expression.\n\n                    For example, if 'app/*.ts' would match 'app/[id].ts', then\n                    on Windows powershell or cmd.exe, 'glob app/*.ts' will\n                    expand to 'app/[id].ts', as expected. However, in posix\n                    shells such as bash or zsh, the shell will first expand\n                    'app/*.ts' to a list of filenames. Then glob will look\n                    for a file matching 'app/[id].ts' (ie, 'app/i.ts' or\n                    'app/d.ts'), which is unexpected.\n\n                    Setting '--all' prevents this behavior, causing glob\n                    to treat ALL patterns as glob expressions to be expanded,\n                    even if they are an exact match to a file on disk.\n\n                    When setting this option, be sure to enquote arguments\n                    so that the shell will not expand them prior to passing\n                    them to the glob command process.\n      `,\n    },\n    absolute: {\n      short: 'a',\n      description: 'Expand to absolute paths',\n    },\n    'dot-relative': {\n      short: 'd',\n      description: `Prepend './' on relative matches`,\n    },\n    mark: {\n      short: 'm',\n      description: `Append a / on any directories matched`,\n    },\n    posix: {\n      short: 'x',\n      description: `Always resolve to posix style paths, using '/' as the\n                    directory separator, even on Windows. Drive letter\n                    absolute matches on Windows will be expanded to their\n                    full resolved UNC maths, eg instead of 'C:\\\\foo\\\\bar',\n                    it will expand to '//?/C:/foo/bar'.\n      `,\n    },\n\n    follow: {\n      short: 'f',\n      description: `Follow symlinked directories when expanding '**'`,\n    },\n    realpath: {\n      short: 'R',\n      description: `Call 'fs.realpath' on all of the results. In the case\n                    of an entry that cannot be resolved, the entry is\n                    omitted. This incurs a slight performance penalty, of\n                    course, because of the added system calls.`,\n    },\n    stat: {\n      short: 's',\n      description: `Call 'fs.lstat' on all entries, whether required or not\n                    to determine if it's a valid match.`,\n    },\n    'match-base': {\n      short: 'b',\n      description: `Perform a basename-only match if the pattern does not\n                    contain any slash characters. That is, '*.js' would be\n                    treated as equivalent to '**/*.js', matching js files\n                    in all directories.\n      `,\n    },\n\n    dot: {\n      description: `Allow patterns to match files/directories that start\n                    with '.', even if the pattern does not start with '.'\n      `,\n    },\n    nobrace: {\n      description: 'Do not expand {...} patterns',\n    },\n    nocase: {\n      description: `Perform a case-insensitive match. This defaults to\n                    'true' on macOS and Windows platforms, and false on\n                    all others.\n\n                    Note: 'nocase' should only be explicitly set when it is\n                    known that the filesystem's case sensitivity differs\n                    from the platform default. If set 'true' on\n                    case-insensitive file systems, then the walk may return\n                    more or less results than expected.\n      `,\n    },\n    nodir: {\n      description: `Do not match directories, only files.\n\n                    Note: to *only* match directories, append a '/' at the\n                    end of the pattern.\n      `,\n    },\n    noext: {\n      description: `Do not expand extglob patterns, such as '+(a|b)'`,\n    },\n    noglobstar: {\n      description: `Do not expand '**' against multiple path portions.\n                    Ie, treat it as a normal '*' instead.`,\n    },\n    'windows-path-no-escape': {\n      description: `Use '\\\\' as a path separator *only*, and *never* as an\n                    escape character. If set, all '\\\\' characters are\n                    replaced with '/' in the pattern.`,\n    },\n  })\n  .num({\n    'max-depth': {\n      short: 'D',\n      description: `Maximum depth to traverse from the current\n                    working directory`,\n    },\n  })\n  .opt({\n    cwd: {\n      short: 'C',\n      description: 'Current working directory to execute/match in',\n      default: process.cwd(),\n    },\n    root: {\n      short: 'r',\n      description: `A string path resolved against the 'cwd', which is\n                    used as the starting point for absolute patterns that\n                    start with '/' (but not drive letters or UNC paths\n                    on Windows).\n\n                    Note that this *doesn't* necessarily limit the walk to\n                    the 'root' directory, and doesn't affect the cwd\n                    starting point for non-absolute patterns. A pattern\n                    containing '..' will still be able to traverse out of\n                    the root directory, if it is not an actual root directory\n                    on the filesystem, and any non-absolute patterns will\n                    still be matched in the 'cwd'.\n\n                    To start absolute and non-absolute patterns in the same\n                    path, you can use '--root=' to set it to the empty\n                    string. However, be aware that on Windows systems, a\n                    pattern like 'x:/*' or '//host/share/*' will *always*\n                    start in the 'x:/' or '//host/share/' directory,\n                    regardless of the --root setting.\n      `,\n    },\n    platform: {\n      description: `Defaults to the value of 'process.platform' if\n                    available, or 'linux' if not. Setting --platform=win32\n                    on non-Windows systems may cause strange behavior!`,\n      validOptions: [\n        'aix',\n        'android',\n        'darwin',\n        'freebsd',\n        'haiku',\n        'linux',\n        'openbsd',\n        'sunos',\n        'win32',\n        'cygwin',\n        'netbsd',\n      ],\n    },\n  })\n  .optList({\n    ignore: {\n      short: 'i',\n      description: `Glob patterns to ignore`,\n    },\n  })\n  .flag({\n    debug: {\n      short: 'v',\n      description: `Output a huge amount of noisy debug information about\n                    patterns as they are parsed and used to match files.`,\n    },\n  })\n  .flag({\n    help: {\n      short: 'h',\n      description: 'Show this usage information',\n    },\n  })\n\ntry {\n  const { positionals, values } = j.parse()\n  if (values.help) {\n    console.log(j.usage())\n    process.exit(0)\n  }\n  if (positionals.length === 0 && !values.default)\n    throw 'No patterns provided'\n  if (positionals.length === 0 && values.default)\n    positionals.push(values.default)\n  const patterns =\n    values.all ? positionals : positionals.filter(p => !existsSync(p))\n  const matches =\n    values.all ?\n      []\n    : positionals.filter(p => existsSync(p)).map(p => join(p))\n  const stream = globStream(patterns, {\n    absolute: values.absolute,\n    cwd: values.cwd,\n    dot: values.dot,\n    dotRelative: values['dot-relative'],\n    follow: values.follow,\n    ignore: values.ignore,\n    mark: values.mark,\n    matchBase: values['match-base'],\n    maxDepth: values['max-depth'],\n    nobrace: values.nobrace,\n    nocase: values.nocase,\n    nodir: values.nodir,\n    noext: values.noext,\n    noglobstar: values.noglobstar,\n    platform: values.platform as undefined | NodeJS.Platform,\n    realpath: values.realpath,\n    root: values.root,\n    stat: values.stat,\n    debug: values.debug,\n    posix: values.posix,\n  })\n\n  const cmd = values.cmd\n  if (!cmd) {\n    matches.forEach(m => console.log(m))\n    stream.on('data', f => console.log(f))\n  } else {\n    stream.on('data', f => matches.push(f))\n    stream.on('end', () => foregroundChild(cmd, matches, { shell: true }))\n  }\n} catch (e) {\n  console.error(j.usage())\n  console.error(e instanceof Error ? e.message : String(e))\n  process.exit(1)\n}\n"]}

package/test/node_modules/glob/dist/esm/glob.d.ts

@@ -1,388 +0,0 @@
-import { Minimatch } from 'minimatch';
-import { Minipass } from 'minipass';
-import { FSOption, Path, PathScurry } from 'path-scurry';
-import { IgnoreLike } from './ignore.js';
-import { Pattern } from './pattern.js';
-export type MatchSet = Minimatch['set'];
-export type GlobParts = Exclude<Minimatch['globParts'], undefined>;
-/**
- * A `GlobOptions` object may be provided to any of the exported methods, and
- * must be provided to the `Glob` constructor.
- *
- * All options are optional, boolean, and false by default, unless otherwise
- * noted.
- *
- * All resolved options are added to the Glob object as properties.
- *
- * If you are running many `glob` operations, you can pass a Glob object as the
- * `options` argument to a subsequent operation to share the previously loaded
- * cache.
- */
-export interface GlobOptions {
-    /**
-     * Set to `true` to always receive absolute paths for
-     * matched files. Set to `false` to always return relative paths.
-     *
-     * When this option is not set, absolute paths are returned for patterns
-     * that are absolute, and otherwise paths are returned that are relative
-     * to the `cwd` setting.
-     *
-     * This does _not_ make an extra system call to get
-     * the realpath, it only does string path resolution.
-     *
-     * Conflicts with {@link withFileTypes}
-     */
-    absolute?: boolean;
-    /**
-     * Set to false to enable {@link windowsPathsNoEscape}
-     *
-     * @deprecated
-     */
-    allowWindowsEscape?: boolean;
-    /**
-     * The current working directory in which to search. Defaults to
-     * `process.cwd()`.
-     *
-     * May be eiher a string path or a `file://` URL object or string.
-     */
-    cwd?: string | URL;
-    /**
-     * Include `.dot` files in normal matches and `globstar`
-     * matches. Note that an explicit dot in a portion of the pattern
-     * will always match dot files.
-     */
-    dot?: boolean;
-    /**
-     * Prepend all relative path strings with `./` (or `.\` on Windows).
-     *
-     * Without this option, returned relative paths are "bare", so instead of
-     * returning `'./foo/bar'`, they are returned as `'foo/bar'`.
-     *
-     * Relative patterns starting with `'../'` are not prepended with `./`, even
-     * if this option is set.
-     */
-    dotRelative?: boolean;
-    /**
-     * Follow symlinked directories when expanding `**`
-     * patterns. This can result in a lot of duplicate references in
-     * the presence of cyclic links, and make performance quite bad.
-     *
-     * By default, a `**` in a pattern will follow 1 symbolic link if
-     * it is not the first item in the pattern, or none if it is the
-     * first item in the pattern, following the same behavior as Bash.
-     */
-    follow?: boolean;
-    /**
-     * string or string[], or an object with `ignore` and `ignoreChildren`
-     * methods.
-     *
-     * If a string or string[] is provided, then this is treated as a glob
-     * pattern or array of glob patterns to exclude from matches. To ignore all
-     * children within a directory, as well as the entry itself, append `'/**'`
-     * to the ignore pattern.
-     *
-     * **Note** `ignore` patterns are _always_ in `dot:true` mode, regardless of
-     * any other settings.
-     *
-     * If an object is provided that has `ignored(path)` and/or
-     * `childrenIgnored(path)` methods, then these methods will be called to
-     * determine whether any Path is a match or if its children should be
-     * traversed, respectively.
-     */
-    ignore?: string | string[] | IgnoreLike;
-    /**
-     * Treat brace expansion like `{a,b}` as a "magic" pattern. Has no
-     * effect if {@link nobrace} is set.
-     *
-     * Only has effect on the {@link hasMagic} function.
-     */
-    magicalBraces?: boolean;
-    /**
-     * Add a `/` character to directory matches. Note that this requires
-     * additional stat calls in some cases.
-     */
-    mark?: boolean;
-    /**
-     * Perform a basename-only match if the pattern does not contain any slash
-     * characters. That is, `*.js` would be treated as equivalent to
-     * `**\/*.js`, matching all js files in all directories.
-     */
-    matchBase?: boolean;
-    /**
-     * Limit the directory traversal to a given depth below the cwd.
-     * Note that this does NOT prevent traversal to sibling folders,
-     * root patterns, and so on. It only limits the maximum folder depth
-     * that the walk will descend, relative to the cwd.
-     */
-    maxDepth?: number;
-    /**
-     * Do not expand `{a,b}` and `{1..3}` brace sets.
-     */
-    nobrace?: boolean;
-    /**
-     * Perform a case-insensitive match. This defaults to `true` on macOS and
-     * Windows systems, and `false` on all others.
-     *
-     * **Note** `nocase` should only be explicitly set when it is
-     * known that the filesystem's case sensitivity differs from the
-     * platform default. If set `true` on case-sensitive file
-     * systems, or `false` on case-insensitive file systems, then the
-     * walk may return more or less results than expected.
-     */
-    nocase?: boolean;
-    /**
-     * Do not match directories, only files. (Note: to match
-     * _only_ directories, put a `/` at the end of the pattern.)
-     */
-    nodir?: boolean;
-    /**
-     * Do not match "extglob" patterns such as `+(a|b)`.
-     */
-    noext?: boolean;
-    /**
-     * Do not match `**` against multiple filenames. (Ie, treat it as a normal
-     * `*` instead.)
-     *
-     * Conflicts with {@link matchBase}
-     */
-    noglobstar?: boolean;
-    /**
-     * Defaults to value of `process.platform` if available, or `'linux'` if
-     * not. Setting `platform:'win32'` on non-Windows systems may cause strange
-     * behavior.
-     */
-    platform?: NodeJS.Platform;
-    /**
-     * Set to true to call `fs.realpath` on all of the
-     * results. In the case of an entry that cannot be resolved, the
-     * entry is omitted. This incurs a slight performance penalty, of
-     * course, because of the added system calls.
-     */
-    realpath?: boolean;
-    /**
-     *
-     * A string path resolved against the `cwd` option, which
-     * is used as the starting point for absolute patterns that start
-     * with `/`, (but not drive letters or UNC paths on Windows).
-     *
-     * Note that this _doesn't_ necessarily limit the walk to the
-     * `root` directory, and doesn't affect the cwd starting point for
-     * non-absolute patterns. A pattern containing `..` will still be
-     * able to traverse out of the root directory, if it is not an
-     * actual root directory on the filesystem, and any non-absolute
-     * patterns will be matched in the `cwd`. For example, the
-     * pattern `/../*` with `{root:'/some/path'}` will return all
-     * files in `/some`, not all files in `/some/path`. The pattern
-     * `*` with `{root:'/some/path'}` will return all the entries in
-     * the cwd, not the entries in `/some/path`.
-     *
-     * To start absolute and non-absolute patterns in the same
-     * path, you can use `{root:''}`. However, be aware that on
-     * Windows systems, a pattern like `x:/*` or `//host/share/*` will
-     * _always_ start in the `x:/` or `//host/share` directory,
-     * regardless of the `root` setting.
-     */
-    root?: string;
-    /**
-     * A [PathScurry](http://npm.im/path-scurry) object used
-     * to traverse the file system. If the `nocase` option is set
-     * explicitly, then any provided `scurry` object must match this
-     * setting.
-     */
-    scurry?: PathScurry;
-    /**
-     * Call `lstat()` on all entries, whether required or not to determine
-     * if it's a valid match. When used with {@link withFileTypes}, this means
-     * that matches will include data such as modified time, permissions, and
-     * so on.  Note that this will incur a performance cost due to the added
-     * system calls.
-     */
-    stat?: boolean;
-    /**
-     * An AbortSignal which will cancel the Glob walk when
-     * triggered.
-     */
-    signal?: AbortSignal;
-    /**
-     * Use `\\` as a path separator _only_, and
-     *  _never_ as an escape character. If set, all `\\` characters are
-     *  replaced with `/` in the pattern.
-     *
-     *  Note that this makes it **impossible** to match against paths
-     *  containing literal glob pattern characters, but allows matching
-     *  with patterns constructed using `path.join()` and
-     *  `path.resolve()` on Windows platforms, mimicking the (buggy!)
-     *  behavior of Glob v7 and before on Windows. Please use with
-     *  caution, and be mindful of [the caveat below about Windows
-     *  paths](#windows). (For legacy reasons, this is also set if
-     *  `allowWindowsEscape` is set to the exact value `false`.)
-     */
-    windowsPathsNoEscape?: boolean;
-    /**
-     * Return [PathScurry](http://npm.im/path-scurry)
-     * `Path` objects instead of strings. These are similar to a
-     * NodeJS `Dirent` object, but with additional methods and
-     * properties.
-     *
-     * Conflicts with {@link absolute}
-     */
-    withFileTypes?: boolean;
-    /**
-     * An fs implementation to override some or all of the defaults.  See
-     * http://npm.im/path-scurry for details about what can be overridden.
-     */
-    fs?: FSOption;
-    /**
-     * Just passed along to Minimatch.  Note that this makes all pattern
-     * matching operations slower and *extremely* noisy.
-     */
-    debug?: boolean;
-    /**
-     * Return `/` delimited paths, even on Windows.
-     *
-     * On posix systems, this has no effect.  But, on Windows, it means that
-     * paths will be `/` delimited, and absolute paths will be their full
-     * resolved UNC forms, eg instead of `'C:\\foo\\bar'`, it would return
-     * `'//?/C:/foo/bar'`
-     */
-    posix?: boolean;
-    /**
-     * Do not match any children of any matches. For example, the pattern
-     * `**\/foo` would match `a/foo`, but not `a/foo/b/foo` in this mode.
-     *
-     * This is especially useful for cases like "find all `node_modules`
-     * folders, but not the ones in `node_modules`".
-     *
-     * In order to support this, the `Ignore` implementation must support an
-     * `add(pattern: string)` method. If using the default `Ignore` class, then
-     * this is fine, but if this is set to `false`, and a custom `Ignore` is
-     * provided that does not have an `add()` method, then it will throw an
-     * error.
-     *
-     * **Caveat** It *only* ignores matches that would be a descendant of a
-     * previous match, and only if that descendant is matched *after* the
-     * ancestor is encountered. Since the file system walk happens in
-     * indeterminate order, it's possible that a match will already be added
-     * before its ancestor, if multiple or braced patterns are used.
-     *
-     * For example:
-     *
-     * ```ts
-     * const results = await glob([
-     *   // likely to match first, since it's just a stat
-     *   'a/b/c/d/e/f',
-     *
-     *   // this pattern is more complicated! It must to various readdir()
-     *   // calls and test the results against a regular expression, and that
-     *   // is certainly going to take a little bit longer.
-     *   //
-     *   // So, later on, it encounters a match at 'a/b/c/d/e', but it's too
-     *   // late to ignore a/b/c/d/e/f, because it's already been emitted.
-     *   'a/[bdf]/?/[a-z]/*',
-     * ], { includeChildMatches: false })
-     * ```
-     *
-     * It's best to only set this to `false` if you can be reasonably sure that
-     * no components of the pattern will potentially match one another's file
-     * system descendants, or if the occasional included child entry will not
-     * cause problems.
-     *
-     * @default true
-     */
-    includeChildMatches?: boolean;
-}
-export type GlobOptionsWithFileTypesTrue = GlobOptions & {
-    withFileTypes: true;
-    absolute?: undefined;
-    mark?: undefined;
-    posix?: undefined;
-};
-export type GlobOptionsWithFileTypesFalse = GlobOptions & {
-    withFileTypes?: false;
-};
-export type GlobOptionsWithFileTypesUnset = GlobOptions & {
-    withFileTypes?: undefined;
-};
-export type Result<Opts> = Opts extends GlobOptionsWithFileTypesTrue ? Path : Opts extends GlobOptionsWithFileTypesFalse ? string : Opts extends GlobOptionsWithFileTypesUnset ? string : string | Path;
-export type Results<Opts> = Result<Opts>[];
-export type FileTypes<Opts> = Opts extends GlobOptionsWithFileTypesTrue ? true : Opts extends GlobOptionsWithFileTypesFalse ? false : Opts extends GlobOptionsWithFileTypesUnset ? false : boolean;
-/**
- * An object that can perform glob pattern traversals.
- */
-export declare class Glob<Opts extends GlobOptions> implements GlobOptions {
-    absolute?: boolean;
-    cwd: string;
-    root?: string;
-    dot: boolean;
-    dotRelative: boolean;
-    follow: boolean;
-    ignore?: string | string[] | IgnoreLike;
-    magicalBraces: boolean;
-    mark?: boolean;
-    matchBase: boolean;
-    maxDepth: number;
-    nobrace: boolean;
-    nocase: boolean;
-    nodir: boolean;
-    noext: boolean;
-    noglobstar: boolean;
-    pattern: string[];
-    platform: NodeJS.Platform;
-    realpath: boolean;
-    scurry: PathScurry;
-    stat: boolean;
-    signal?: AbortSignal;
-    windowsPathsNoEscape: boolean;
-    withFileTypes: FileTypes<Opts>;
-    includeChildMatches: boolean;
-    /**
-     * The options provided to the constructor.
-     */
-    opts: Opts;
-    /**
-     * An array of parsed immutable {@link Pattern} objects.
-     */
-    patterns: Pattern[];
-    /**
-     * All options are stored as properties on the `Glob` object.
-     *
-     * See {@link GlobOptions} for full options descriptions.
-     *
-     * Note that a previous `Glob` object can be passed as the
-     * `GlobOptions` to another `Glob` instantiation to re-use settings
-     * and caches with a new pattern.
-     *
-     * Traversal functions can be called multiple times to run the walk
-     * again.
-     */
-    constructor(pattern: string | string[], opts: Opts);
-    /**
-     * Returns a Promise that resolves to the results array.
-     */
-    walk(): Promise<Results<Opts>>;
-    /**
-     * synchronous {@link Glob.walk}
-     */
-    walkSync(): Results<Opts>;
-    /**
-     * Stream results asynchronously.
-     */
-    stream(): Minipass<Result<Opts>, Result<Opts>>;
-    /**
-     * Stream results synchronously.
-     */
-    streamSync(): Minipass<Result<Opts>, Result<Opts>>;
-    /**
-     * Default sync iteration function. Returns a Generator that
-     * iterates over the results.
-     */
-    iterateSync(): Generator<Result<Opts>, void, void>;
-    [Symbol.iterator](): Generator<Result<Opts>, void, void>;
-    /**
-     * Default async iteration function. Returns an AsyncGenerator that
-     * iterates over the results.
-     */
-    iterate(): AsyncGenerator<Result<Opts>, void, void>;
-    [Symbol.asyncIterator](): AsyncGenerator<Result<Opts>, void, void>;
-}
-//# sourceMappingURL=glob.d.ts.map