@baic/yolk-cli 2.1.0-alpha.9 → 2.1.0-github.0

package/compiled/glob/package.json

@@ -0,0 +1 @@
+{"name":"glob","author":"Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)","license":"ISC"}

package/compiled/minimatch/index.d.ts

@@ -0,0 +1,312 @@
+export declare type braceExpand = minimatch.braceExpand;
+
+export declare type defaults = minimatch.defaults;
+
+export declare type filter = minimatch.filter;
+
+export declare type IMinimatch = minimatch.IMinimatch;
+
+export declare type IMinimatchStatic = minimatch.IMinimatchStatic;
+
+export declare type IOptions = minimatch.IOptions;
+
+export declare type makeRe = minimatch.makeRe;
+
+export declare type match = minimatch.match;
+
+export declare type Minimatch = minimatch.Minimatch;
+
+/**
+ * Tests a path against the pattern using the options.
+ *
+ * @example
+ * import minimatch = require("minimatch");
+ *
+ * const isJS = minimatch(file, "*.js", { matchBase: true });
+ */
+declare function minimatch(target: string, pattern: string, options?: minimatch.IOptions): boolean;
+
+declare namespace minimatch {
+    /**
+     * Match against the list of files, in the style of fnmatch or glob.
+     * If nothing is matched, and options.nonull is set,
+     * then return a list containing the pattern itself.
+     *
+     * @example
+     * import minimatch = require("minimatch");
+     *
+     * const javascripts = minimatch.match(fileList, "*.js", {matchBase: true});
+     */
+    function match(list: readonly string[], pattern: string, options?: IOptions): string[];
+
+    /**
+     * @return A function that tests its supplied argument, suitable for use with `Array.filter`.
+     *
+     * @example
+     * import minimatch = require("minimatch");
+     *
+     * const javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}));
+     */
+    function filter(
+    pattern: string,
+    options?: IOptions,
+    ): (element: string, indexed: number, array: readonly string[]) => boolean;
+
+    /**
+     * Make a regular expression object from the pattern.
+     */
+    function makeRe(pattern: string, options?: IOptions): RegExp | false;
+
+    function defaults(defaultOptions: IOptions): typeof minimatch;
+
+    function braceExpand(pattern: string, options?: IOptions): string[];
+
+    const sep: string;
+    const GLOBSTAR: unique symbol;
+
+    interface IOptions {
+        /**
+         * Dump a ton of stuff to stderr.
+         *
+         * @default false
+         */
+        debug?: boolean | undefined;
+
+        /**
+         * Do not expand `{a,b}` and `{1..3}` brace sets.
+         *
+         * @default false
+         */
+        nobrace?: boolean | undefined;
+
+        /**
+         * Disable `**` matching against multiple folder names.
+         *
+         * @default false
+         */
+        noglobstar?: boolean | undefined;
+
+        /**
+         * Allow patterns to match filenames starting with a period,
+         * even if the pattern does not explicitly have a period in that spot.
+         *
+         * Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
+         *
+         * @default false
+         */
+        dot?: boolean | undefined;
+
+        /**
+         * Disable "extglob" style patterns like `+(a|b)`.
+         *
+         * @default false
+         */
+        noext?: boolean | undefined;
+
+        /**
+         * Perform a case-insensitive match.
+         *
+         * @default false
+         */
+        nocase?: boolean | undefined;
+
+        /**
+         * When a match is not found by `minimatch.match`,
+         * return a list containing the pattern itself if this option is set.
+         * Otherwise, an empty list is returned if there are no matches.
+         *
+         * @default false
+         */
+        nonull?: boolean | undefined;
+
+        /**
+         * If set, then patterns without slashes will be matched
+         * against the basename of the path if it contains slashes. For example,
+         * `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
+         *
+         * @default false
+         */
+        matchBase?: boolean | undefined;
+
+        /**
+         * Suppress the behavior of treating `#` at the start of a pattern as a comment.
+         *
+         * @default false
+         */
+        nocomment?: boolean | undefined;
+
+        /**
+         * Suppress the behavior of treating a leading `!` character as negation.
+         *
+         * @default false
+         */
+        nonegate?: boolean | undefined;
+
+        /**
+         * Returns from negate expressions the same as if they were not negated.
+         * (Ie, true on a hit, false on a miss.)
+         *
+         * @default false
+         */
+        flipNegate?: boolean | undefined;
+
+        /**
+         * Compare a partial path to a pattern.  As long as the parts of the path that
+         * are present are not contradicted by the pattern, it will be treated as a
+         * match. This is useful in applications where you're walking through a
+         * folder structure, and don't yet have the full path, but want to ensure that
+         * you do not walk down paths that can never be a match.
+         *
+         * @default false
+         *
+         * @example
+         * import minimatch = require("minimatch");
+         *
+         * minimatch('/a/b', '/a/*' + '/c/d', { partial: true })  // true, might be /a/b/c/d
+         * minimatch('/a/b', '/**' + '/d', { partial: true })     // true, might be /a/b/.../d
+         * minimatch('/x/y/z', '/a/**' + '/z', { partial: true }) // false, because x !== a
+         */
+        partial?: boolean;
+
+        /**
+         * 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 earlier versions on Windows. Please use with
+         * caution, and be mindful of the caveat about Windows paths
+         *
+         * For legacy reasons, this is also set if
+         * `options.allowWindowsEscape` is set to the exact value `false`.
+         *
+         * @default false
+         */
+        windowsPathsNoEscape?: boolean;
+    }
+
+    /**
+     * @deprecated Keep legacy interface to prevent unnecessary breakage.
+     */
+    type IMinimatchStatic = typeof Minimatch;
+    /**
+     * @deprecated Keep legacy interface to prevent unnecessary breakage.
+     */
+    type IMinimatch = Minimatch;
+
+    /**
+     * Create a minimatch object by instantiating the `minimatch.Minimatch` class.
+     *
+     * @example
+     * import { Minimatch } from "minimatch";
+     *
+     * const mm = new Minimatch(pattern, options);
+     */
+    class Minimatch {
+        constructor(pattern: string, options?: IOptions);
+
+        static defaults(defaultOptions: IOptions): typeof Minimatch;
+
+        /**
+         * The original pattern the minimatch object represents.
+         */
+        pattern: string;
+
+        /**
+         * The options supplied to the constructor.
+         */
+        options: IOptions;
+
+        /**
+         * A 2-dimensional array of regexp or string expressions. Each row in the array corresponds
+         * to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For
+         * example, the pattern `{a,b/c}/d` would expand to a set of patterns like:
+         *
+         * ```
+         *   [ [ a, d ]
+         *   , [ b, c, d ] ]
+         * ```
+         *
+         * If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"``
+         * rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression.
+         */
+        set: Array<Array<RegExp | string>>;
+
+        /**
+         * Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is
+         * useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
+         */
+        regexp: RegExp | false | null;
+
+        /**
+         * True if the pattern is negated.
+         */
+        negate: boolean;
+
+        /**
+         * True if the pattern is a comment.
+         */
+        comment: boolean;
+
+        /**
+         * True if the pattern is `""`.
+         */
+        empty: boolean;
+
+        /**
+         * True if windows path delimiters shouldn't be interpreted as escape characters.
+         */
+        windowsPathsNoEscape: boolean;
+
+        /**
+         * True if partial paths should be compared to a pattern.
+         */
+        partial: boolean;
+
+        /**
+         * Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid.
+         */
+        makeRe(): RegExp | false;
+
+        /**
+         * @return `true` if the filename matches the pattern, or `false` otherwise.
+         */
+        match(fname: string, partial?: boolean): boolean;
+
+        /**
+         * Take a `/`-split filename, and match it against a single row in the `regExpSet`.
+         * This method is mainly for internal use, but is exposed so that it can be used
+         * by a glob-walker that needs to avoid excessive filesystem calls.
+         */
+        matchOne(file: readonly string[], pattern: ReadonlyArray<string | RegExp>, partial: boolean): boolean;
+
+        /**
+         * @deprecated. For internal use.
+         */
+        debug(): void;
+
+        /**
+         * @deprecated. For internal use.
+         */
+        make(): void;
+
+        /**
+         * @deprecated. For internal use.
+         */
+        parseNegate(): void;
+
+        /**
+         * @deprecated. For internal use.
+         */
+        braceExpand(): string[];
+
+        /**
+         * @deprecated. For internal use.
+         */
+        parse(pattern: string, isSub?: boolean): string | false | [string, boolean] | RegExp | typeof GLOBSTAR;
+    }
+}
+export default minimatch;
+
+export { }