@unpackjs/core 1.5.3 → 1.6.0

package/compiled/css-loader/license

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+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.

package/compiled/css-loader/noSourceMaps.js

@@ -0,0 +1,5 @@
+"use strict";
+
+module.exports = function (i) {
+  return i[1];
+};

package/compiled/css-loader/package.json

@@ -0,0 +1 @@
+{"name":"css-loader","author":"Tobias Koppers @sokra","version":"7.1.2","funding":{"type":"opencollective","url":"https://opencollective.com/webpack"},"license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/css-loader/sourceMaps.js

@@ -0,0 +1,16 @@
+"use strict";
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+  if (!cssMapping) {
+    return content;
+  }
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    return [content].concat([sourceMapping]).join("\n");
+  }
+  return [content].join("\n");
+};

package/compiled/fast-glob/index.d.ts

@@ -0,0 +1,237 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+
+declare type ErrnoException$1 = NodeJS.ErrnoException;
+
+declare type StatAsynchronousMethod = (path: string, callback: (error: ErrnoException$1 | null, stats: fs.Stats) => void) => void;
+declare type StatSynchronousMethod = (path: string) => fs.Stats;
+interface FileSystemAdapter$2 {
+    lstat: StatAsynchronousMethod;
+    stat: StatAsynchronousMethod;
+    lstatSync: StatSynchronousMethod;
+    statSync: StatSynchronousMethod;
+}
+
+interface Entry$2 {
+    dirent: Dirent;
+    name: string;
+    path: string;
+    stats?: Stats;
+}
+declare type Stats = fs.Stats;
+declare type ErrnoException = NodeJS.ErrnoException;
+interface Dirent {
+    isBlockDevice: () => boolean;
+    isCharacterDevice: () => boolean;
+    isDirectory: () => boolean;
+    isFIFO: () => boolean;
+    isFile: () => boolean;
+    isSocket: () => boolean;
+    isSymbolicLink: () => boolean;
+    name: string;
+}
+
+interface ReaddirAsynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }, callback: (error: ErrnoException | null, files: Dirent[]) => void): void;
+    (filepath: string, callback: (error: ErrnoException | null, files: string[]) => void): void;
+}
+interface ReaddirSynchronousMethod {
+    (filepath: string, options: {
+        withFileTypes: true;
+    }): Dirent[];
+    (filepath: string): string[];
+}
+declare type FileSystemAdapter$1 = FileSystemAdapter$2 & {
+    readdir: ReaddirAsynchronousMethod;
+    readdirSync: ReaddirSynchronousMethod;
+};
+
+declare type Entry$1 = Entry$2;
+
+type Entry = Entry$1;
+type Pattern = string;
+type FileSystemAdapter = FileSystemAdapter$1;
+
+type Options = {
+    /**
+     * Return the absolute path for entries.
+     *
+     * @default false
+     */
+    absolute?: boolean;
+    /**
+     * If set to `true`, then patterns without slashes will be matched against
+     * the basename of the path if it contains slashes.
+     *
+     * @default false
+     */
+    baseNameMatch?: boolean;
+    /**
+     * Enables Bash-like brace expansion.
+     *
+     * @default true
+     */
+    braceExpansion?: boolean;
+    /**
+     * Enables a case-sensitive mode for matching files.
+     *
+     * @default true
+     */
+    caseSensitiveMatch?: boolean;
+    /**
+     * Specifies the maximum number of concurrent requests from a reader to read
+     * directories.
+     *
+     * @default os.cpus().length
+     */
+    concurrency?: number;
+    /**
+     * The current working directory in which to search.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Specifies the maximum depth of a read directory relative to the start
+     * directory.
+     *
+     * @default Infinity
+     */
+    deep?: number;
+    /**
+     * Allow patterns to match entries that begin with a period (`.`).
+     *
+     * @default false
+     */
+    dot?: boolean;
+    /**
+     * Enables Bash-like `extglob` functionality.
+     *
+     * @default true
+     */
+    extglob?: boolean;
+    /**
+     * Indicates whether to traverse descendants of symbolic link directories.
+     *
+     * @default true
+     */
+    followSymbolicLinks?: boolean;
+    /**
+     * Custom implementation of methods for working with the file system.
+     *
+     * @default fs.*
+     */
+    fs?: Partial<FileSystemAdapter>;
+    /**
+     * Enables recursively repeats a pattern containing `**`.
+     * If `false`, `**` behaves exactly like `*`.
+     *
+     * @default true
+     */
+    globstar?: boolean;
+    /**
+     * An array of glob patterns to exclude matches.
+     * This is an alternative way to use negative patterns.
+     *
+     * @default []
+     */
+    ignore?: Pattern[];
+    /**
+     * Mark the directory path with the final slash.
+     *
+     * @default false
+     */
+    markDirectories?: boolean;
+    /**
+     * Returns objects (instead of strings) describing entries.
+     *
+     * @default false
+     */
+    objectMode?: boolean;
+    /**
+     * Return only directories.
+     *
+     * @default false
+     */
+    onlyDirectories?: boolean;
+    /**
+     * Return only files.
+     *
+     * @default true
+     */
+    onlyFiles?: boolean;
+    /**
+     * Enables an object mode (`objectMode`) with an additional `stats` field.
+     *
+     * @default false
+     */
+    stats?: boolean;
+    /**
+     * By default this package suppress only `ENOENT` errors.
+     * Set to `true` to suppress any error.
+     *
+     * @default false
+     */
+    suppressErrors?: boolean;
+    /**
+     * Throw an error when symbolic link is broken if `true` or safely
+     * return `lstat` call if `false`.
+     *
+     * @default false
+     */
+    throwErrorOnBrokenSymbolicLink?: boolean;
+    /**
+     * Ensures that the returned entries are unique.
+     *
+     * @default true
+     */
+    unique?: boolean;
+};
+
+type Task = {
+    base: string;
+    dynamic: boolean;
+    patterns: Pattern[];
+    positive: Pattern[];
+    negative: Pattern[];
+};
+
+type EntryObjectModePredicate = {
+    [TKey in keyof Pick<Options, 'objectMode'>]-?: true;
+};
+type EntryStatsPredicate = {
+    [TKey in keyof Pick<Options, 'stats'>]-?: true;
+};
+type EntryObjectPredicate = EntryObjectModePredicate | EntryStatsPredicate;
+declare function FastGlob(source: Pattern | Pattern[], options: Options & EntryObjectPredicate): Promise<Entry[]>;
+declare function FastGlob(source: Pattern | Pattern[], options?: Options): Promise<string[]>;
+declare namespace FastGlob {
+    type Options = Options;
+    type Entry = Entry;
+    type Task = Task;
+    type Pattern = Pattern;
+    type FileSystemAdapter = FileSystemAdapter;
+    const glob: typeof FastGlob;
+    const globSync: typeof sync;
+    const globStream: typeof stream;
+    const async: typeof FastGlob;
+    function sync(source: Pattern | Pattern[], options: Options & EntryObjectPredicate): Entry[];
+    function sync(source: Pattern | Pattern[], options?: Options): string[];
+    function stream(source: Pattern | Pattern[], options?: Options): NodeJS.ReadableStream;
+    function generateTasks(source: Pattern | Pattern[], options?: Options): Task[];
+    function isDynamicPattern(source: Pattern, options?: Options): boolean;
+    function escapePath(source: string): Pattern;
+    function convertPathToPattern(source: string): Pattern;
+    namespace posix {
+        function escapePath(source: string): Pattern;
+        function convertPathToPattern(source: string): Pattern;
+    }
+    namespace win32 {
+        function escapePath(source: string): Pattern;
+        function convertPathToPattern(source: string): Pattern;
+    }
+}
+
+export { FastGlob as default };