@naturalcycles/nodejs-lib 13.45.4 → 14.0.1

package/dist/fs/fs2.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 
 Why?
@@ -14,18 +13,15 @@ That's why function names are slightly renamed, to avoid conflict.
 Credit to: fs-extra (https://github.com/jprichardson/node-fs-extra)
 
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fs2 = void 0;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const promises_1 = tslib_1.__importDefault(require("node:fs/promises"));
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const node_zlib_1 = require("node:zlib");
-const js_lib_1 = require("@naturalcycles/js-lib");
-const js_yaml_1 = tslib_1.__importDefault(require("js-yaml"));
-const transformToNDJson_1 = require("../stream/ndjson/transformToNDJson");
-const transformSplit_1 = require("../stream/transform/transformSplit");
-const env_util_1 = require("../util/env.util");
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { createGzip, createUnzip } from 'node:zlib';
+import { _isTruthy, _jsonParse } from '@naturalcycles/js-lib';
+import yaml from 'js-yaml';
+import { transformToNDJson } from '../stream/ndjson/transformToNDJson.js';
+import { transformSplitOnNewline } from '../stream/transform/transformSplit.js';
+import { requireFileToExist } from '../util/env.util.js';
 /**
  * fs2 conveniently groups filesystem functions together.
  * Supposed to be almost a drop-in replacement for these things together:
@@ -42,62 +38,62 @@ class FS2 {
      * Convenience wrapper that defaults to utf-8 string output.
      */
     readText(filePath) {
-        return node_fs_1.default.readFileSync(filePath, 'utf8');
+        return fs.readFileSync(filePath, 'utf8');
     }
     /**
      * Convenience wrapper that defaults to utf-8 string output.
      */
     async readTextAsync(filePath) {
-        return await promises_1.default.readFile(filePath, 'utf8');
+        return await fsp.readFile(filePath, 'utf8');
     }
     readBuffer(filePath) {
-        return node_fs_1.default.readFileSync(filePath);
+        return fs.readFileSync(filePath);
     }
     async readBufferAsync(filePath) {
-        return await promises_1.default.readFile(filePath);
+        return await fsp.readFile(filePath);
     }
     readJson(filePath) {
-        const str = node_fs_1.default.readFileSync(filePath, 'utf8');
-        return (0, js_lib_1._jsonParse)(str);
+        const str = fs.readFileSync(filePath, 'utf8');
+        return _jsonParse(str);
     }
     async readJsonAsync(filePath) {
-        const str = await promises_1.default.readFile(filePath, 'utf8');
+        const str = await fsp.readFile(filePath, 'utf8');
         // eslint-disable-next-line @typescript-eslint/return-await
-        return (0, js_lib_1._jsonParse)(str);
+        return _jsonParse(str);
     }
     readYaml(filePath) {
-        return js_yaml_1.default.load(node_fs_1.default.readFileSync(filePath, 'utf8'));
+        return yaml.load(fs.readFileSync(filePath, 'utf8'));
     }
     async readYamlAsync(filePath) {
-        return js_yaml_1.default.load(await promises_1.default.readFile(filePath, 'utf8'));
+        return yaml.load(await fsp.readFile(filePath, 'utf8'));
     }
     writeFile(filePath, data) {
-        node_fs_1.default.writeFileSync(filePath, data);
+        fs.writeFileSync(filePath, data);
     }
     async writeFileAsync(filePath, data) {
-        await promises_1.default.writeFile(filePath, data);
+        await fsp.writeFile(filePath, data);
     }
     writeJson(filePath, data, opt) {
         const str = stringify(data, opt);
-        node_fs_1.default.writeFileSync(filePath, str);
+        fs.writeFileSync(filePath, str);
     }
     async writeJsonAsync(filePath, data, opt) {
         const str = stringify(data, opt);
-        await promises_1.default.writeFile(filePath, str);
+        await fsp.writeFile(filePath, str);
     }
     writeYaml(filePath, data, opt) {
-        const str = js_yaml_1.default.dump(data, opt);
-        node_fs_1.default.writeFileSync(filePath, str);
+        const str = yaml.dump(data, opt);
+        fs.writeFileSync(filePath, str);
     }
     async writeYamlAsync(filePath, data, opt) {
-        const str = js_yaml_1.default.dump(data, opt);
-        await promises_1.default.writeFile(filePath, str);
+        const str = yaml.dump(data, opt);
+        await fsp.writeFile(filePath, str);
     }
     appendFile(filePath, data) {
-        node_fs_1.default.appendFileSync(filePath, data);
+        fs.appendFileSync(filePath, data);
     }
     async appendFileAsync(filePath, data) {
-        await promises_1.default.appendFile(filePath, data);
+        await fsp.appendFile(filePath, data);
     }
     outputJson(filePath, data, opt) {
         const str = stringify(data, opt);
@@ -108,33 +104,33 @@ class FS2 {
         await this.outputFileAsync(filePath, str);
     }
     outputYaml(filePath, data, opt) {
-        const str = js_yaml_1.default.dump(data, opt);
+        const str = yaml.dump(data, opt);
         this.outputFile(filePath, str);
     }
     async outputYamlAsync(filePath, data, opt) {
-        const str = js_yaml_1.default.dump(data, opt);
+        const str = yaml.dump(data, opt);
         await this.outputFileAsync(filePath, str);
     }
     outputFile(filePath, data) {
-        const dirPath = node_path_1.default.dirname(filePath);
-        if (!node_fs_1.default.existsSync(dirPath)) {
+        const dirPath = path.dirname(filePath);
+        if (!fs.existsSync(dirPath)) {
             this.ensureDir(dirPath);
         }
-        node_fs_1.default.writeFileSync(filePath, data);
+        fs.writeFileSync(filePath, data);
     }
     async outputFileAsync(filePath, data) {
-        const dirPath = node_path_1.default.dirname(filePath);
+        const dirPath = path.dirname(filePath);
         if (!(await this.pathExistsAsync(dirPath))) {
             await this.ensureDirAsync(dirPath);
         }
-        await promises_1.default.writeFile(filePath, data);
+        await fsp.writeFile(filePath, data);
     }
     pathExists(filePath) {
-        return node_fs_1.default.existsSync(filePath);
+        return fs.existsSync(filePath);
     }
     async pathExistsAsync(filePath) {
         try {
-            await promises_1.default.access(filePath);
+            await fsp.access(filePath);
             return true;
         }
         catch {
@@ -142,13 +138,13 @@ class FS2 {
         }
     }
     ensureDir(dirPath) {
-        node_fs_1.default.mkdirSync(dirPath, {
+        fs.mkdirSync(dirPath, {
             mode: 0o777,
             recursive: true,
         });
     }
     async ensureDirAsync(dirPath) {
-        await promises_1.default.mkdir(dirPath, {
+        await fsp.mkdir(dirPath, {
             mode: 0o777,
             recursive: true,
         });
@@ -156,17 +152,17 @@ class FS2 {
     ensureFile(filePath) {
         let stats;
         try {
-            stats = node_fs_1.default.statSync(filePath);
+            stats = fs.statSync(filePath);
         }
         catch { }
         if (stats?.isFile())
             return;
-        const dir = node_path_1.default.dirname(filePath);
+        const dir = path.dirname(filePath);
         try {
-            if (!node_fs_1.default.statSync(dir).isDirectory()) {
+            if (!fs.statSync(dir).isDirectory()) {
                 // parent is not a directory
                 // This is just to cause an internal ENOTDIR error to be thrown
-                node_fs_1.default.readdirSync(dir);
+                fs.readdirSync(dir);
             }
         }
         catch (err) {
@@ -177,22 +173,22 @@ class FS2 {
             }
             throw err;
         }
-        node_fs_1.default.writeFileSync(filePath, '');
+        fs.writeFileSync(filePath, '');
     }
     async ensureFileAsync(filePath) {
         let stats;
         try {
-            stats = await promises_1.default.stat(filePath);
+            stats = await fsp.stat(filePath);
         }
         catch { }
         if (stats?.isFile())
             return;
-        const dir = node_path_1.default.dirname(filePath);
+        const dir = path.dirname(filePath);
         try {
-            if (!(await promises_1.default.stat(dir)).isDirectory()) {
+            if (!(await fsp.stat(dir)).isDirectory()) {
                 // parent is not a directory
                 // This is just to cause an internal ENOTDIR error to be thrown
-                await promises_1.default.readdir(dir);
+                await fsp.readdir(dir);
             }
         }
         catch (err) {
@@ -201,40 +197,40 @@ class FS2 {
                 return await this.ensureDirAsync(dir);
             throw err;
         }
-        await promises_1.default.writeFile(filePath, '');
+        await fsp.writeFile(filePath, '');
     }
     removePath(fileOrDirPath, opt) {
-        node_fs_1.default.rmSync(fileOrDirPath, { recursive: true, force: true, ...opt });
+        fs.rmSync(fileOrDirPath, { recursive: true, force: true, ...opt });
     }
     async removePathAsync(fileOrDirPath, opt) {
-        await promises_1.default.rm(fileOrDirPath, { recursive: true, force: true, ...opt });
+        await fsp.rm(fileOrDirPath, { recursive: true, force: true, ...opt });
     }
     emptyDir(dirPath) {
         let items;
         try {
-            items = node_fs_1.default.readdirSync(dirPath);
+            items = fs.readdirSync(dirPath);
         }
         catch {
             this.ensureDir(dirPath);
             return;
         }
-        items.forEach(item => this.removePath(node_path_1.default.join(dirPath, item)));
+        items.forEach(item => this.removePath(path.join(dirPath, item)));
     }
     async emptyDirAsync(dirPath) {
         let items;
         try {
-            items = await promises_1.default.readdir(dirPath);
+            items = await fsp.readdir(dirPath);
         }
         catch {
             return await this.ensureDirAsync(dirPath);
         }
-        await Promise.all(items.map(item => this.removePathAsync(node_path_1.default.join(dirPath, item))));
+        await Promise.all(items.map(item => this.removePathAsync(path.join(dirPath, item))));
     }
     /**
      * Cautious, underlying Node function is currently Experimental.
      */
     copyPath(src, dest, opt) {
-        node_fs_1.default.cpSync(src, dest, {
+        fs.cpSync(src, dest, {
             recursive: true,
             ...opt,
         });
@@ -243,16 +239,16 @@ class FS2 {
      * Cautious, underlying Node function is currently Experimental.
      */
     async copyPathAsync(src, dest, opt) {
-        await promises_1.default.cp(src, dest, {
+        await fsp.cp(src, dest, {
             recursive: true,
             ...opt,
         });
     }
     renamePath(src, dest) {
-        node_fs_1.default.renameSync(src, dest);
+        fs.renameSync(src, dest);
     }
     async renamePathAsync(src, dest) {
-        await promises_1.default.rename(src, dest);
+        await fsp.rename(src, dest);
     }
     movePath(src, dest, opt) {
         this.copyPath(src, dest, opt);
@@ -268,27 +264,27 @@ class FS2 {
      * Doesn't throw, returns false instead.
      */
     isDirectory(filePath) {
-        return (exports.fs2
+        return (fs2
             .stat(filePath, {
             throwIfNoEntry: false,
         })
             ?.isDirectory() || false);
     }
     // Re-export the whole fs/fsp, for the edge cases where they are needed
-    fs = node_fs_1.default;
-    fsp = promises_1.default;
+    fs = fs;
+    fsp = fsp;
     // Re-export existing fs/fsp functions
     // rm/rmAsync are replaced with removePath/removePathAsync
-    lstat = node_fs_1.default.lstatSync;
-    lstatAsync = promises_1.default.lstat;
-    stat = node_fs_1.default.statSync;
-    statAsync = promises_1.default.stat;
-    mkdir = node_fs_1.default.mkdirSync;
-    mkdirAsync = promises_1.default.mkdir;
-    readdir = node_fs_1.default.readdirSync;
-    readdirAsync = promises_1.default.readdir;
-    createWriteStream = node_fs_1.default.createWriteStream;
-    createReadStream = node_fs_1.default.createReadStream;
+    lstat = fs.lstatSync;
+    lstatAsync = fsp.lstat;
+    stat = fs.statSync;
+    statAsync = fsp.stat;
+    mkdir = fs.mkdirSync;
+    mkdirAsync = fsp.mkdir;
+    readdir = fs.readdirSync;
+    readdirAsync = fsp.readdir;
+    createWriteStream = fs.createWriteStream;
+    createReadStream = fs.createReadStream;
     /*
     Returns a Readable of [already parsed] NDJSON objects.
   
@@ -307,18 +303,18 @@ class FS2 {
     ])
      */
     createReadStreamAsNDJSON(inputPath) {
-        (0, env_util_1.requireFileToExist)(inputPath);
-        let stream = node_fs_1.default
+        requireFileToExist(inputPath);
+        let stream = fs
             .createReadStream(inputPath, {
             highWaterMark: 64 * 1024, // no observed speedup
         })
             .on('error', err => stream.emit('error', err));
         if (inputPath.endsWith('.gz')) {
-            stream = stream.pipe((0, node_zlib_1.createUnzip)({
+            stream = stream.pipe(createUnzip({
                 chunkSize: 64 * 1024, // speedup from ~3200 to 3800 rps!
             }));
         }
-        return stream.pipe((0, transformSplit_1.transformSplitOnNewline)()).map(line => JSON.parse(line));
+        return stream.pipe(transformSplitOnNewline()).map(line => JSON.parse(line));
         // For some crazy reason .map is much faster than transformJsonParse!
         // ~5000 vs ~4000 rps !!!
         // .on('error', err => stream.emit('error', err))
@@ -336,19 +332,19 @@ class FS2 {
     createWriteStreamAsNDJSON(outputPath) {
         this.ensureFile(outputPath);
         return [
-            (0, transformToNDJson_1.transformToNDJson)(),
+            transformToNDJson(),
             outputPath.endsWith('.gz')
-                ? (0, node_zlib_1.createGzip)({
+                ? createGzip({
                 // chunkSize: 64 * 1024, // no observed speedup
                 })
                 : undefined,
-            node_fs_1.default.createWriteStream(outputPath, {
+            fs.createWriteStream(outputPath, {
             // highWaterMark: 64 * 1024, // no observed speedup
             }),
-        ].filter(js_lib_1._isTruthy);
+        ].filter(_isTruthy);
     }
 }
-exports.fs2 = new FS2();
+export const fs2 = new FS2();
 function stringify(data, opt) {
     // If pretty-printing is enabled (spaces) - also add a newline at the end (to match our prettier config)
     return JSON.stringify(data, null, opt?.spaces) + (opt?.spaces ? '\n' : '');

package/dist/fs/json2env.js

@@ -1,28 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.json2env = json2env;
-exports.appendToBashEnv = appendToBashEnv;
-exports.appendToGithubEnv = appendToGithubEnv;
-exports.appendToGithubOutput = appendToGithubOutput;
-exports.appendToGithubSummary = appendToGithubSummary;
-exports.objectToShellExport = objectToShellExport;
-exports.objectToGithubActionsEnv = objectToGithubActionsEnv;
-const tslib_1 = require("tslib");
-const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
-const colors_1 = require("../colors/colors");
-const fs2_1 = require("./fs2");
+import fs from 'node:fs';
+import { dimGrey } from '../colors/colors.js';
+import { fs2 } from './fs2.js';
 const JSON2ENV_OPT_DEF = {
     saveEnvFile: true,
     bashEnv: true,
     githubEnv: true,
     fail: true,
 };
-function json2env(opt) {
+export function json2env(opt) {
     const { jsonPath, prefix, saveEnvFile, bashEnv, githubEnv, fail, debug, silent } = {
         ...JSON2ENV_OPT_DEF,
         ...opt,
     };
-    if (!fs2_1.fs2.pathExists(jsonPath)) {
+    if (!fs2.pathExists(jsonPath)) {
         if (fail) {
             throw new Error(`Path doesn't exist: ${jsonPath}`);
         }
@@ -35,16 +25,16 @@ function json2env(opt) {
         return;
     }
     // read file
-    const json = fs2_1.fs2.readJson(jsonPath);
+    const json = fs2.readJson(jsonPath);
     if (debug) {
         console.log(json);
     }
     if (saveEnvFile) {
         const shPath = `${jsonPath}.sh`;
         const exportStr = objectToShellExport(json, prefix);
-        fs2_1.fs2.writeFile(shPath, exportStr);
+        fs2.writeFile(shPath, exportStr);
         if (!silent) {
-            console.log(`json2env created ${(0, colors_1.dimGrey)(shPath)}:`);
+            console.log(`json2env created ${dimGrey(shPath)}:`);
             console.log(exportStr);
         }
     }
@@ -56,38 +46,38 @@ function json2env(opt) {
         appendToGithubOutput(json, prefix);
     }
 }
-function appendToBashEnv(obj, prefix = '') {
+export function appendToBashEnv(obj, prefix = '') {
     const { BASH_ENV } = process.env;
     if (BASH_ENV) {
         const data = objectToShellExport(obj, prefix);
-        node_fs_1.default.appendFileSync(BASH_ENV, data);
+        fs.appendFileSync(BASH_ENV, data);
         console.log(`BASH_ENV appended:\n${data}`);
     }
 }
-function appendToGithubEnv(obj, prefix = '') {
+export function appendToGithubEnv(obj, prefix = '') {
     const { GITHUB_ENV } = process.env;
     if (GITHUB_ENV) {
         const data = objectToGithubActionsEnv(obj, prefix);
-        node_fs_1.default.appendFileSync(GITHUB_ENV, data);
+        fs.appendFileSync(GITHUB_ENV, data);
         console.log(`GITHUB_ENV appended:\n${data}`);
     }
 }
-function appendToGithubOutput(obj, prefix = '') {
+export function appendToGithubOutput(obj, prefix = '') {
     const { GITHUB_OUTPUT } = process.env;
     if (GITHUB_OUTPUT) {
         const data = objectToGithubActionsEnv(obj, prefix);
-        node_fs_1.default.appendFileSync(GITHUB_OUTPUT, data);
+        fs.appendFileSync(GITHUB_OUTPUT, data);
         console.log(`GITHUB_OUTPUT appended:\n${data}`);
     }
 }
 /**
  * https://docs.github.com/en/actions/using-workflows/workflow-commands-for-github-actions#adding-a-job-summary
  */
-function appendToGithubSummary(...lines) {
+export function appendToGithubSummary(...lines) {
     const { GITHUB_STEP_SUMMARY } = process.env;
     if (GITHUB_STEP_SUMMARY) {
         const str = lines.join('\n') + '\n';
-        node_fs_1.default.appendFileSync(GITHUB_STEP_SUMMARY, str);
+        fs.appendFileSync(GITHUB_STEP_SUMMARY, str);
         console.log(`GITHUB_STEP_SUMMARY appended:\n${str}`);
     }
 }
@@ -105,7 +95,7 @@ function appendToGithubSummary(...lines) {
  * Quotes are important, otherwise it'll break on e.g space character in the value.
  * Includes trailing newline for composability.
  */
-function objectToShellExport(obj, prefix = '') {
+export function objectToShellExport(obj, prefix = '') {
     if (!Object.keys(obj).length)
         return '';
     return (Object.entries(obj)
@@ -133,7 +123,7 @@ function objectToShellExport(obj, prefix = '') {
  *
  * UPD: Quoted values behave inconsistently, so we're trying to NOT quote now, and-see-what-happens.
  */
-function objectToGithubActionsEnv(obj, prefix = '') {
+export function objectToGithubActionsEnv(obj, prefix = '') {
     if (!Object.keys(obj).length)
         return '';
     return (Object.entries(obj)

package/dist/fs/kpy.js

@@ -1,64 +1,59 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.kpy = kpy;
-exports.kpySync = kpySync;
-const tslib_1 = require("tslib");
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const js_lib_1 = require("@naturalcycles/js-lib");
-const colors_1 = require("../colors/colors");
-const index_1 = require("../index");
-async function kpy(opt) {
-    const started = js_lib_1.localTime.nowUnixMillis();
+import path from 'node:path';
+import { _since, localTime } from '@naturalcycles/js-lib';
+import { boldWhite, dimGrey, grey, yellow } from '../colors/colors.js';
+import { fastGlob, fs2 } from '../index.js';
+export async function kpy(opt) {
+    const started = localTime.nowUnixMillis();
     kpyPrepare(opt);
-    const filenames = await (0, index_1.fastGlob)(opt.inputPatterns, {
+    const filenames = await fastGlob(opt.inputPatterns, {
         cwd: opt.baseDir,
         dot: opt.dotfiles,
     });
     kpyLogFilenames(opt, filenames);
     const overwrite = !opt.noOverwrite;
     await Promise.all(filenames.map(async (filename) => {
-        const basename = node_path_1.default.basename(filename);
-        const srcFilename = node_path_1.default.resolve(opt.baseDir, filename);
-        const destFilename = node_path_1.default.resolve(opt.outputDir, opt.flat ? basename : filename);
+        const basename = path.basename(filename);
+        const srcFilename = path.resolve(opt.baseDir, filename);
+        const destFilename = path.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                await index_1.fs2.movePathAsync(srcFilename, destFilename, {
+                await fs2.movePathAsync(srcFilename, destFilename, {
                     force: overwrite,
                 });
             }
             else {
-                await index_1.fs2.copyPathAsync(srcFilename, destFilename, { force: overwrite });
+                await fs2.copyPathAsync(srcFilename, destFilename, { force: overwrite });
             }
         }
         if (opt.verbose) {
-            console.log((0, colors_1.grey)(`  ${filename}`));
+            console.log(grey(`  ${filename}`));
         }
     }));
     kpyLogResult(opt, filenames, started);
 }
-function kpySync(opt) {
-    const started = js_lib_1.localTime.nowUnixMillis();
+export function kpySync(opt) {
+    const started = localTime.nowUnixMillis();
     kpyPrepare(opt);
-    const filenames = index_1.fastGlob.sync(opt.inputPatterns, {
+    const filenames = fastGlob.sync(opt.inputPatterns, {
         cwd: opt.baseDir,
         dot: opt.dotfiles,
     });
     kpyLogFilenames(opt, filenames);
     const overwrite = !opt.noOverwrite;
     filenames.forEach(filename => {
-        const basename = node_path_1.default.basename(filename);
-        const srcFilename = node_path_1.default.resolve(opt.baseDir, filename);
-        const destFilename = node_path_1.default.resolve(opt.outputDir, opt.flat ? basename : filename);
+        const basename = path.basename(filename);
+        const srcFilename = path.resolve(opt.baseDir, filename);
+        const destFilename = path.resolve(opt.outputDir, opt.flat ? basename : filename);
         if (!opt.dry) {
             if (opt.move) {
-                index_1.fs2.movePath(srcFilename, destFilename, { force: overwrite });
+                fs2.movePath(srcFilename, destFilename, { force: overwrite });
             }
             else {
-                index_1.fs2.copyPath(srcFilename, destFilename, { force: overwrite });
+                fs2.copyPath(srcFilename, destFilename, { force: overwrite });
             }
         }
         if (opt.verbose) {
-            console.log((0, colors_1.grey)(`  ${filename}`));
+            console.log(grey(`  ${filename}`));
         }
     });
     kpyLogResult(opt, filenames, started);
@@ -70,17 +65,17 @@ function kpyPrepare(opt) {
     // default to cwd
     opt.baseDir ||= '.';
     opt.outputDir ||= '.';
-    if (!index_1.fs2.pathExists(opt.baseDir)) {
-        console.log(`kpy: baseDir doesn't exist: ${(0, colors_1.boldWhite)(opt.baseDir)}`);
+    if (!fs2.pathExists(opt.baseDir)) {
+        console.log(`kpy: baseDir doesn't exist: ${boldWhite(opt.baseDir)}`);
         return;
     }
-    index_1.fs2.ensureDir(opt.outputDir);
+    fs2.ensureDir(opt.outputDir);
     // Expand directories (ex-globby feature), experimental!
     const extraPatterns = [];
     for (const pattern of opt.inputPatterns) {
         if (pattern.includes('*'))
             continue;
-        if (index_1.fs2.isDirectory(node_path_1.default.resolve(opt.baseDir, pattern))) {
+        if (fs2.isDirectory(path.resolve(opt.baseDir, pattern))) {
             extraPatterns.push(`${pattern}/**`);
         }
     }
@@ -93,10 +88,10 @@ function kpyLogFilenames(opt, filenames) {
     if (opt.silent)
         return;
     // console.log({filenames})
-    console.log(`Will ${opt.move ? 'move' : 'copy'} ${(0, colors_1.yellow)(filenames.length)} files from ${(0, colors_1.dimGrey)(opt.baseDir)} to ${(0, colors_1.dimGrey)(opt.outputDir)} (${(0, colors_1.dimGrey)(opt.inputPatterns.join(' '))})`);
+    console.log(`Will ${opt.move ? 'move' : 'copy'} ${yellow(filenames.length)} files from ${dimGrey(opt.baseDir)} to ${dimGrey(opt.outputDir)} (${dimGrey(opt.inputPatterns.join(' '))})`);
 }
 function kpyLogResult(opt, filenames, started) {
     if (opt.silent || filenames.length === 0)
         return;
-    console.log(`${opt.move ? 'Moved' : 'Copied'} ${(0, colors_1.yellow)(filenames.length)} files to ${(0, colors_1.dimGrey)(opt.outputDir)} ${(0, colors_1.dimGrey)((0, js_lib_1._since)(started))}`);
+    console.log(`${opt.move ? 'Moved' : 'Copied'} ${yellow(filenames.length)} files to ${dimGrey(opt.outputDir)} ${dimGrey(_since(started))}`);
 }