@modern-js/utils 1.3.6 → 1.3.7-alpha.prebundle.0

package/dist/FileSizeReporter.js

@@ -0,0 +1,151 @@
+/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+// Modified by Chao Xu (xuchaobei)
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printFileSizesAfterBuild = exports.measureFileSizesBeforeBuild = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const logger_1 = require("./logger");
+function canReadAsset(asset) {
+    return (/\.(js|css)$/.test(asset) &&
+        !/service-worker\.js/.test(asset) &&
+        !/precache-manifest\.[0-9a-f]+\.js/.test(asset));
+}
+// Prints a detailed summary of build files.
+function printFileSizesAfterBuild(webpackStats, previousSizeMap, buildFolder, maxBundleGzipSize, maxChunkGzipSize) {
+    var root = previousSizeMap.root;
+    var sizes = previousSizeMap.sizes;
+    var assets = (webpackStats.stats || [webpackStats])
+        .map((stats) => stats
+        .toJson({ all: false, assets: true })
+        .assets.filter((asset) => canReadAsset(asset.name))
+        .map((asset) => {
+        var fileContents = fs_1.default.readFileSync(path_1.default.join(root, asset.name));
+        var size = fileContents.length;
+        var gzippedSize = compiled_1.gzipSize.sync(fileContents);
+        var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
+        var sizeDifference = getDifferenceLabel(size, previousSize);
+        var gzipSizeDifference = getDifferenceLabel(gzippedSize, previousGzipSize);
+        return {
+            folder: path_1.default.join(path_1.default.basename(buildFolder), path_1.default.dirname(asset.name)),
+            name: path_1.default.basename(asset.name),
+            gzippedSize: gzippedSize,
+            sizeLabel: (0, compiled_1.filesize)(size) +
+                (sizeDifference ? ' (' + sizeDifference + ')' : ''),
+            gzipSizeLabel: (0, compiled_1.filesize)(gzippedSize) +
+                (gzipSizeDifference ? ' (' + gzipSizeDifference + ')' : ''),
+        };
+    }))
+        .reduce((single, all) => all.concat(single), []);
+    assets.sort((a, b) => b.size - a.size);
+    var longestSizeLabelLength = Math.max.apply(null, assets.map((a) => (0, compiled_1.stripAnsi)(a.sizeLabel).length));
+    var longestFileNameLength = Math.max.apply(null, assets.map((a) => (0, compiled_1.stripAnsi)(a.folder + path_1.default.sep + a.name).length));
+    printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
+    var suggestBundleSplitting = false;
+    assets.forEach((asset) => {
+        var { folder, name, sizeLabel, gzipSizeLabel, gzippedSize } = asset;
+        var fileNameLength = (0, compiled_1.stripAnsi)(folder + path_1.default.sep + name).length;
+        var sizeLength = (0, compiled_1.stripAnsi)(sizeLabel).length;
+        if (sizeLength < longestSizeLabelLength) {
+            var rightPadding = ' '.repeat(longestSizeLabelLength - sizeLength);
+            sizeLabel += rightPadding;
+        }
+        var fileNameLabel = compiled_1.chalk.dim(asset.folder + path_1.default.sep) + compiled_1.chalk.cyan(asset.name);
+        if (fileNameLength < longestFileNameLength) {
+            var rightPadding = ' '.repeat(longestFileNameLength - fileNameLength);
+            fileNameLabel += rightPadding;
+        }
+        var isMainBundle = asset.name.indexOf('main.') === 0;
+        var maxRecommendedSize = isMainBundle
+            ? maxBundleGzipSize
+            : maxChunkGzipSize;
+        var isLarge = maxRecommendedSize && gzippedSize > maxRecommendedSize;
+        if (isLarge && path_1.default.extname(asset.name) === '.js') {
+            suggestBundleSplitting = true;
+        }
+        logger_1.logger.log('  ' +
+            fileNameLabel +
+            '    ' +
+            sizeLabel +
+            '    ' +
+            (isLarge ? compiled_1.chalk.yellow(gzipSizeLabel) : gzipSizeLabel));
+    });
+    if (suggestBundleSplitting) {
+        logger_1.logger.log();
+        logger_1.logger.warn('The bundle size is significantly larger than recommended.');
+    }
+}
+exports.printFileSizesAfterBuild = printFileSizesAfterBuild;
+function printFileSizesHeader(longestFileNameLength, longestSizeLabelLength) {
+    const longestLengths = [longestFileNameLength, longestSizeLabelLength];
+    const headerRow = ['File', 'Size', 'Gzipped'].reduce((prev, cur, index) => {
+        const length = longestLengths[index];
+        let curLabel = cur;
+        if (length) {
+            curLabel =
+                cur.length < length ? cur + ' '.repeat(length - cur.length) : cur;
+        }
+        return prev + curLabel + '    ';
+    }, '  ');
+    logger_1.logger.log(compiled_1.chalk.bold(compiled_1.chalk.blue(headerRow)));
+}
+function removeFileNameHash(buildFolder, fileName) {
+    return fileName
+        .replace(buildFolder, '')
+        .replace(/\\/g, '/')
+        .replace(/\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/, (match, p1, p2, p3, p4) => p1 + p4);
+}
+// Input: 1024, 2048
+// Output: "(+1 KB)"
+function getDifferenceLabel(currentSize, previousSize) {
+    var FIFTY_KILOBYTES = 1024 * 50;
+    var difference = currentSize - previousSize;
+    var fileSize = !Number.isNaN(difference) ? (0, compiled_1.filesize)(difference) : 0;
+    if (difference >= FIFTY_KILOBYTES) {
+        return compiled_1.chalk.red('+' + fileSize);
+    }
+    else if (difference < FIFTY_KILOBYTES && difference > 0) {
+        return compiled_1.chalk.yellow('+' + fileSize);
+    }
+    else if (difference < 0) {
+        return compiled_1.chalk.green(fileSize);
+    }
+    else {
+        return '';
+    }
+}
+function measureFileSizesBeforeBuild(buildFolder) {
+    return new Promise(resolve => {
+        (0, compiled_1.recursiveReaddir)(buildFolder, (err, fileNames) => {
+            var sizes;
+            if (!err && fileNames) {
+                sizes = fileNames
+                    .filter(canReadAsset)
+                    .reduce((memo, fileName) => {
+                    var contents = fs_1.default.readFileSync(fileName);
+                    var key = removeFileNameHash(buildFolder, fileName);
+                    // save both the original size and gzip size
+                    memo[key] = [contents.length, compiled_1.gzipSize.sync(contents)];
+                    return memo;
+                }, {});
+            }
+            resolve({
+                root: buildFolder,
+                sizes: sizes || {},
+            });
+        });
+    });
+}
+exports.measureFileSizesBeforeBuild = measureFileSizesBeforeBuild;

package/dist/{types/alias.d.ts → alias.d.ts}

@@ -1,23 +1,21 @@
 declare type AliasOption = Record<string, string> | ((aliases: Record<string, string>) => Record<string, unknown>) | Record<string, string> | undefined;
 interface NormalizedConfig {
-  source: {
-    alias?: AliasOption | Array<AliasOption>;
-  };
+    source: {
+        alias?: AliasOption | Array<AliasOption>;
+    };
 }
 interface IAliasConfig {
-  absoluteBaseUrl: string;
-  paths?: Record<string, string | string[]>;
-  isTsPath?: boolean;
-  isTsProject?: boolean;
+    absoluteBaseUrl: string;
+    paths?: Record<string, string | string[]>;
+    isTsPath?: boolean;
+    isTsProject?: boolean;
 }
-export declare const validAlias: <T extends NormalizedConfig>(modernConfig: T, {
-  tsconfigPath
-}: {
-  tsconfigPath: string;
+export declare const validAlias: <T extends NormalizedConfig>(modernConfig: T, { tsconfigPath }: {
+    tsconfigPath: string;
 }) => string | null;
 export declare const getAlias: (aliasOption: AliasOption | Array<AliasOption>, option: {
-  appDirectory: string;
-  tsconfigPath: string;
+    appDirectory: string;
+    tsconfigPath: string;
 }) => IAliasConfig;
 export declare const getUserAlias: (alias?: Record<string, string | string[]>) => Record<string, string | string[]>;
-export {};
+export {};

package/dist/alias.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserAlias = exports.getAlias = exports.validAlias = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compiled_1 = require("./compiled");
+const readTsConfig_1 = require("./readTsConfig");
+const applyOptionsChain_1 = require("./applyOptionsChain");
+const validAlias = (modernConfig, { tsconfigPath }) => {
+    const { source: { alias }, } = modernConfig;
+    if (!alias) {
+        return null;
+    }
+    const isTsProject = fs_1.default.existsSync(tsconfigPath);
+    if (!isTsProject) {
+        return null;
+    }
+    const userAlias = (0, exports.getUserAlias)(alias);
+    if (Object.keys(userAlias).length > 0) {
+        return compiled_1.chalk.red('Note: Please use `compilerOptions.paths` in "tsconfig.json" file replace `source.alias` config in "modern.config.js/ts" when project is typescript');
+    }
+    return null;
+};
+exports.validAlias = validAlias;
+const getAlias = (aliasOption, option) => {
+    var _a, _b;
+    const isTsProject = fs_1.default.existsSync(option.tsconfigPath);
+    let aliasConfig;
+    if (!isTsProject) {
+        aliasConfig = {
+            absoluteBaseUrl: option.appDirectory,
+            paths: (0, applyOptionsChain_1.applyOptionsChain)({ '@': ['./src'] }, aliasOption),
+            isTsPath: false,
+            isTsProject,
+        };
+    }
+    else {
+        const tsconfig = (0, readTsConfig_1.readTsConfigByFile)(option.tsconfigPath);
+        const baseUrl = (_a = tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl;
+        aliasConfig = {
+            absoluteBaseUrl: baseUrl
+                ? path_1.default.join(option.appDirectory, baseUrl)
+                : option.appDirectory,
+            paths: Object.assign(Object.assign({}, (aliasOption || {})), (_b = tsconfig === null || tsconfig === void 0 ? void 0 : tsconfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.paths),
+            isTsPath: true,
+            isTsProject,
+        };
+    }
+    return aliasConfig;
+};
+exports.getAlias = getAlias;
+// filter invalid ts paths that are not array
+const getUserAlias = (alias = {}) => Object.keys(alias).reduce((o, k) => {
+    if (Array.isArray(alias[k])) {
+        o[k] = alias[k];
+    }
+    return o;
+}, {});
+exports.getUserAlias = getUserAlias;

package/dist/applyOptionsChain.d.ts

@@ -0,0 +1,6 @@
+export declare const applyOptionsChain: <T, U>(defaults: T, options?: T | (T | ((config: T, utils?: U | undefined) => void | T))[] | ((config: T, utils?: U | undefined) => void | T) | undefined, utils?: U | undefined, mergeFn?: {
+    <T_1, U_1>(target: T_1, source: U_1): T_1 & U_1;
+    <T_2, U_2, V>(target: T_2, source1: U_2, source2: V): T_2 & U_2 & V;
+    <T_3, U_3, V_1, W>(target: T_3, source1: U_3, source2: V_1, source3: W): T_3 & U_3 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}) => T;

package/dist/applyOptionsChain.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyOptionsChain = void 0;
+// eslint-disable-next-line import/no-useless-path-segments
+const index_1 = require("./index");
+const applyOptionsChain = (defaults, options, utils, mergeFn = Object.assign) => {
+    if (!options) {
+        return defaults;
+    }
+    if ((0, index_1.isPlainObject)(options)) {
+        return mergeFn(defaults, options);
+    }
+    else if ((0, index_1.isFunction)(options)) {
+        const ret = options(defaults, utils);
+        if (ret) {
+            if (!(0, index_1.isPlainObject)(ret)) {
+                index_1.logger.warn(`${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`);
+            }
+            return ret;
+        }
+    }
+    else if (Array.isArray(options)) {
+        return options.reduce((memo, cur) => (0, exports.applyOptionsChain)(memo, cur, utils, mergeFn), defaults);
+    }
+    else {
+        throw new Error(`applyOptionsChain error:\ndefault options is: ${JSON.stringify(defaults)}`);
+    }
+    return defaults;
+};
+exports.applyOptionsChain = applyOptionsChain;

package/dist/clearConsole.d.ts

@@ -0,0 +1 @@
+export declare const clearConsole: () => void;

package/dist/clearConsole.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearConsole = void 0;
+const clearConsole = () => {
+    if (process.stdout.isTTY && !process.env.DEBUG) {
+        process.stdout.write('\x1B[H\x1B[2J');
+    }
+};
+exports.clearConsole = clearConsole;

package/dist/{types/compatRequire.d.ts → compatRequire.d.ts}

@@ -5,4 +5,4 @@
  */
 export declare const compatRequire: (filePath: string) => any;
 export declare const requireExistModule: (filename: string, extensions?: string[]) => any;
-export declare const cleanRequireCache: (filelist: string[]) => void;
+export declare const cleanRequireCache: (filelist: string[]) => void;

package/dist/compatRequire.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanRequireCache = exports.requireExistModule = exports.compatRequire = void 0;
+const findExists_1 = require("./findExists");
+/**
+ * Require function compatible with esm and cjs module.
+ * @param filePath - File to required.
+ * @returns module export object.
+ */
+const compatRequire = (filePath) => {
+    const mod = require(filePath);
+    return (mod === null || mod === void 0 ? void 0 : mod.__esModule) ? mod.default : mod;
+};
+exports.compatRequire = compatRequire;
+const requireExistModule = (filename, extensions = ['.ts', '.js']) => {
+    const exist = (0, findExists_1.findExists)(extensions.map(ext => `${filename}${ext}`));
+    if (!exist) {
+        return null;
+    }
+    return (0, exports.compatRequire)(exist);
+};
+exports.requireExistModule = requireExistModule;
+const cleanRequireCache = (filelist) => {
+    filelist.forEach(filepath => {
+        delete require.cache[filepath];
+    });
+};
+exports.cleanRequireCache = cleanRequireCache;

package/dist/compiled/upath/index.d.ts

@@ -0,0 +1,225 @@
+declare module "upath" {
+    /**
+     * A parsed path object generated by path.parse() or consumed by path.format().
+     */
+    interface ParsedPath {
+        /**
+         * The root of the path such as '/' or 'c:\'
+         */
+        root: string;
+        /**
+         * The full directory path such as '/home/user/dir' or 'c:\path\dir'
+         */
+        dir: string;
+        /**
+         * The file name including extension (if any) such as 'index.html'
+         */
+        base: string;
+        /**
+         * The file extension (if any) such as '.html'
+         */
+        ext: string;
+        /**
+         * The file name without extension (if any) such as 'index'
+         */
+        name: string;
+    }
+    /**
+     * Version of the library
+     */
+    var VERSION: string;
+    /**
+     * Just converts all `to/` and consolidates duplicates, without performing any normalization.
+     *
+     * @param p string path to convert to unix.
+     */
+    function toUnix(p: string): string;
+    /**
+     * Exactly like path.normalize(path), but it keeps the first meaningful ./.
+     *
+     * Note that the unix / is returned everywhere, so windows \ is always converted to unix /.
+     *
+     * @param p string path to normalize.
+     */
+    function normalizeSafe(p: string): string;
+    /**
+     * Exactly like path.normalizeSafe(path), but it trims any useless ending /.
+     *
+     * @param p string path to normalize
+     */
+    function normalizeTrim(p: string): string;
+    /**
+     * Exactly like path.join(), but it keeps the first meaningful ./.
+     *
+     * Note that the unix / is returned everywhere, so windows \ is always converted to unix /.
+     *
+     * @param paths string paths to join
+     */
+    function joinSafe(...p: any[]): string;
+    /**
+     * Adds .ext to filename, but only if it doesn't already have the exact extension.
+     *
+     * @param file string filename to add extension to
+     * @param ext string extension to add
+     */
+    function addExt(file: string, ext: string): string;
+    /**
+     * Trims a filename's extension.
+     *
+     * Extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).
+     *
+     * An Array of ignoreExts (eg ['.min']) prevents these from being considered as extension, thus are not trimmed.
+     *
+     * @param filename string filename to trim it's extension
+     * @param ignoreExts array extensions to ignore
+     * @param maxSize number max length of the extension
+     */
+    function trimExt(filename: string, ignoreExts?: string[], maxSize?: number): string;
+    /**
+     * Removes the specific ext extension from filename, if it has it. Otherwise it leaves it as is. As in all upath functions, it be .ext or ext.
+     *
+     * @param file string filename to remove extension to
+     * @param ext string extension to remove
+     */
+    function removeExt(filename: string, ext: string): string;
+    /**
+     * Changes a filename's extension to ext. If it has no (valid) extension, it adds it.
+     *
+     * Valid extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).
+     *
+     * An Array of ignoreExts (eg ['.min']) prevents these from being considered as extension, thus are not changed - the new extension is added instead.
+     *
+     * @param filename string filename to change it's extension
+     * @param ext string extension to change to
+     * @param ignoreExts array extensions to ignore
+     * @param maxSize number max length of the extension
+     */
+    function changeExt(filename: string, ext: string, ignoreExts?: string[], maxSize?: number): string;
+    /**
+     * Adds .ext to filename, only if it doesn't already have any old extension.
+     *
+     * (Old) extensions are considered to be up to maxSize chars long, counting the dot (defaults to 7).
+     *
+     * An Array of ignoreExts (eg ['.min']) will force adding default .ext even if one of these is present.
+     *
+     * @param filename string filename to default to it's extension
+     * @param ext string extension to default to
+     * @param ignoreExts array extensions to ignore
+     * @param maxSize number max length of the extension
+     */
+    function defaultExt(filename: string, ext: string, ignoreExts?: string[], maxSize?: number): string;
+    /**
+     * Normalize a string path, reducing '..' and '.' parts.
+     * When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
+     *
+     * @param p string path to normalize.
+     */
+    function normalize(p: string): string;
+    /**
+     * Join all arguments together and normalize the resulting path.
+     * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
+     *
+     * @param paths string paths to join.
+     */
+    function join(...paths: any[]): string;
+    /**
+     * Join all arguments together and normalize the resulting path.
+     * Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
+     *
+     * @param paths string paths to join.
+     */
+    function join(...paths: string[]): string;
+    /**
+     * The right-most parameter is considered {to}.  Other parameters are considered an array of {from}.
+     *
+     * Starting from leftmost {from} parameter, resolves {to} to an absolute path.
+     *
+     * If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.
+     *
+     * @param pathSegments string paths to join.  Non-string arguments are ignored.
+     */
+    function resolve(...pathSegments: any[]): string;
+    /**
+     * Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
+     *
+     * @param path path to test.
+     */
+    function isAbsolute(path: string): boolean;
+    /**
+     * Solve the relative path from {from} to {to}.
+     * At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
+     *
+     * @param from
+     * @param to
+     */
+    function relative(from: string, to: string): string;
+    /**
+     * Return the directory name of a path. Similar to the Unix dirname command.
+     *
+     * @param p the path to evaluate.
+     */
+    function dirname(p: string): string;
+    /**
+     * Return the last portion of a path. Similar to the Unix basename command.
+     * Often used to extract the file name from a fully qualified path.
+     *
+     * @param p the path to evaluate.
+     * @param ext optionally, an extension to remove from the result.
+     */
+    function basename(p: string, ext?: string): string;
+    /**
+     * Return the extension of the path, from the last '.' to end of string in the last portion of the path.
+     * If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string
+     *
+     * @param p the path to evaluate.
+     */
+    function extname(p: string): string;
+    /**
+     * The platform-specific file separator. '\\' or '/'.
+     */
+    var sep: string;
+    /**
+     * The platform-specific file delimiter. ';' or ':'.
+     */
+    var delimiter: string;
+    /**
+     * Returns an object from a path string - the opposite of format().
+     *
+     * @param pathString path to evaluate.
+     */
+    function parse(pathString: string): ParsedPath;
+    /**
+     * Returns a path string from an object - the opposite of parse().
+     *
+     * @param pathString path to evaluate.
+     */
+    function format(pathObject: ParsedPath): string;
+    module posix {
+        function normalize(p: string): string;
+        function join(...paths: any[]): string;
+        function resolve(...pathSegments: any[]): string;
+        function isAbsolute(p: string): boolean;
+        function relative(from: string, to: string): string;
+        function dirname(p: string): string;
+        function basename(p: string, ext?: string): string;
+        function extname(p: string): string;
+        var sep: string;
+        var delimiter: string;
+        function parse(p: string): ParsedPath;
+        function format(pP: ParsedPath): string;
+    }
+    module win32 {
+        function normalize(p: string): string;
+        function join(...paths: any[]): string;
+        function resolve(...pathSegments: any[]): string;
+        function isAbsolute(p: string): boolean;
+        function relative(from: string, to: string): string;
+        function dirname(p: string): string;
+        function basename(p: string, ext?: string): string;
+        function extname(p: string): string;
+        var sep: string;
+        var delimiter: string;
+        function parse(p: string): ParsedPath;
+        function format(pP: ParsedPath): string;
+    }
+}

package/dist/compiled/upath/index.js

@@ -0,0 +1 @@
+"use strict";

package/dist/compiled.d.ts

@@ -0,0 +1,21 @@
+import fs from '../compiled/fs-extra';
+import chalk from '../compiled/chalk';
+import lodash from '../compiled/lodash';
+import signale from '../compiled/signale';
+export { fs, chalk, lodash, signale };
+export { program, Command } from '../compiled/commander';
+export { Signale, SignaleOptions } from '../compiled/signale';
+export type { IOptions as GlobOptions } from '../compiled/glob';
+export type { FSWatcher, WatchOptions } from '../compiled/chokidar';
+export declare const glob: typeof import('../compiled/glob');
+export declare const yaml: typeof import('../compiled/js-yaml');
+export declare const execa: typeof import('../compiled/execa');
+export declare const pkgUp: typeof import('../compiled/pkg-up');
+export declare const upath: typeof import('../compiled/upath');
+export declare const debug: typeof import('../compiled/debug');
+export declare const chokidar: typeof import('../compiled/chokidar');
+export declare const gzipSize: typeof import('../compiled/gzip-size');
+export declare const filesize: typeof import('../compiled/filesize');
+export declare const stripAnsi: typeof import('../compiled/strip-ansi');
+export declare const browserslist: typeof import('../compiled/browserslist');
+export declare const recursiveReaddir: typeof import('../compiled/recursive-readdir');

package/dist/compiled.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recursiveReaddir = exports.browserslist = exports.stripAnsi = exports.filesize = exports.gzipSize = exports.chokidar = exports.debug = exports.upath = exports.pkgUp = exports.execa = exports.yaml = exports.glob = exports.SignaleOptions = exports.Signale = exports.Command = exports.program = exports.signale = exports.lodash = exports.chalk = exports.fs = void 0;
+const fs_extra_1 = __importDefault(require("../compiled/fs-extra"));
+exports.fs = fs_extra_1.default;
+const chalk_1 = __importDefault(require("../compiled/chalk"));
+exports.chalk = chalk_1.default;
+const lodash_1 = __importDefault(require("../compiled/lodash"));
+exports.lodash = lodash_1.default;
+const signale_1 = __importDefault(require("../compiled/signale"));
+exports.signale = signale_1.default;
+const import_1 = require("./import");
+var commander_1 = require("../compiled/commander");
+Object.defineProperty(exports, "program", { enumerable: true, get: function () { return commander_1.program; } });
+Object.defineProperty(exports, "Command", { enumerable: true, get: function () { return commander_1.Command; } });
+var signale_2 = require("../compiled/signale");
+Object.defineProperty(exports, "Signale", { enumerable: true, get: function () { return signale_2.Signale; } });
+Object.defineProperty(exports, "SignaleOptions", { enumerable: true, get: function () { return signale_2.SignaleOptions; } });
+exports.glob = import_1.Import.lazy('../compiled/glob', require);
+exports.yaml = import_1.Import.lazy('../compiled/js-yaml', require);
+exports.execa = import_1.Import.lazy('../compiled/execa', require);
+exports.pkgUp = import_1.Import.lazy('../compiled/pkg-up', require);
+exports.upath = import_1.Import.lazy('../compiled/upath', require);
+exports.debug = import_1.Import.lazy('../compiled/debug', require);
+exports.chokidar = import_1.Import.lazy('../compiled/chokidar', require);
+exports.gzipSize = import_1.Import.lazy('../compiled/gzip-size', require);
+exports.filesize = import_1.Import.lazy('../compiled/filesize', require);
+exports.stripAnsi = import_1.Import.lazy('../compiled/strip-ansi', require);
+exports.browserslist = import_1.Import.lazy('../compiled/browserslist', require);
+exports.recursiveReaddir = import_1.Import.lazy('../compiled/recursive-readdir', require);