@cspell/cspell-tools 7.0.0-alpha.1 → 7.0.0

package/dist/config/index.js

@@ -1,10 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeConfig = exports.isFileSource = exports.isFilePath = exports.isFileListSource = void 0;
-var configUtils_1 = require("./configUtils");
-Object.defineProperty(exports, "isFileListSource", { enumerable: true, get: function () { return configUtils_1.isFileListSource; } });
-Object.defineProperty(exports, "isFilePath", { enumerable: true, get: function () { return configUtils_1.isFilePath; } });
-Object.defineProperty(exports, "isFileSource", { enumerable: true, get: function () { return configUtils_1.isFileSource; } });
-var normalizeConfig_1 = require("./normalizeConfig");
-Object.defineProperty(exports, "normalizeConfig", { enumerable: true, get: function () { return normalizeConfig_1.normalizeConfig; } });
+export { isFileListSource, isFilePath, isFileSource } from './configUtils.js';
+export { normalizeConfig } from './normalizeConfig.js';
 //# sourceMappingURL=index.js.map

package/dist/config/normalizeConfig.js

@@ -1,31 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeConfig = void 0;
-const path = __importStar(require("path"));
-function normalizeConfig(cfg) {
+import * as path from 'path';
+export function normalizeConfig(cfg) {
     if (!cfg)
         return cfg;
     const dir = path.dirname(cfg.filepath);
@@ -36,5 +10,4 @@ function normalizeConfig(cfg) {
         filepath: cfg.filepath,
     };
 }
-exports.normalizeConfig = normalizeConfig;
 //# sourceMappingURL=normalizeConfig.js.map

package/dist/gzip/compressFiles.d.ts

@@ -0,0 +1,2 @@
+export declare function compressFile(file: string): Promise<string>;
+//# sourceMappingURL=compressFiles.d.ts.map

package/dist/gzip/compressFiles.js

@@ -0,0 +1,14 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { gzip as gz } from 'node:zlib';
+const gzip = promisify(gz);
+export async function compressFile(file) {
+    if (file.endsWith('.gz'))
+        return file;
+    const targetFile = file + '.gz';
+    const buf = await readFile(file);
+    const zBuf = await gzip(buf);
+    await writeFile(targetFile, zBuf);
+    return targetFile;
+}
+//# sourceMappingURL=compressFiles.js.map

package/dist/gzip/gzip.d.ts

@@ -0,0 +1,2 @@
+export declare function gzip(globs: string[]): Promise<void>;
+//# sourceMappingURL=gzip.d.ts.map

package/dist/gzip/gzip.js

@@ -0,0 +1,10 @@
+import { globP } from '../util/globP.js';
+import { compressFile } from './compressFiles.js';
+// cspell:ignore nodir
+export async function gzip(globs) {
+    const files = await globP(globs, { nodir: true });
+    for (const fileName of files) {
+        await compressFile(fileName);
+    }
+}
+//# sourceMappingURL=gzip.js.map

package/dist/gzip/index.d.ts

@@ -0,0 +1,3 @@
+export { compressFile } from './compressFiles.js';
+export { gzip } from './gzip.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gzip/index.js

@@ -0,0 +1,3 @@
+export { compressFile } from './compressFiles.js';
+export { gzip } from './gzip.js';
+//# sourceMappingURL=index.js.map

package/dist/shasum/checksum.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+type HashAlgorithm = 'SHA1';
+export declare function calcChecksum(buf: Buffer, alg?: HashAlgorithm): string;
+export declare function checkChecksum(checksum: string, buf: Buffer, alg?: HashAlgorithm): boolean;
+export declare function calcFileChecksum(filename: string, alg?: HashAlgorithm): Promise<string>;
+export declare function checkFile(checksum: string, filename: string, alg?: HashAlgorithm): Promise<boolean>;
+export {};
+//# sourceMappingURL=checksum.d.ts.map

package/dist/shasum/checksum.js

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+export function calcChecksum(buf, alg = 'SHA1') {
+    const hash = createHash(alg);
+    hash.update(buf);
+    return hash.digest('hex');
+}
+export function checkChecksum(checksum, buf, alg) {
+    const value = calcChecksum(buf, alg);
+    return value === checksum;
+}
+export async function calcFileChecksum(filename, alg) {
+    const buf = await readFile(filename);
+    return calcChecksum(buf, alg);
+}
+export async function checkFile(checksum, filename, alg) {
+    return (await calcFileChecksum(filename, alg)) === checksum;
+}
+//# sourceMappingURL=checksum.js.map

package/dist/shasum/index.d.ts

@@ -0,0 +1,3 @@
+export { calcFileChecksum } from './checksum.js';
+export { checkShasumFile, updateChecksumForFiles } from './shasum.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shasum/index.js

@@ -0,0 +1,3 @@
+export { calcFileChecksum } from './checksum.js';
+export { checkShasumFile, updateChecksumForFiles } from './shasum.js';
+//# sourceMappingURL=index.js.map

package/dist/shasum/shasum.d.ts

@@ -0,0 +1,38 @@
+export interface CheckShasumFileResult {
+    passed: boolean;
+    results: CheckFileResult[];
+}
+export interface CheckFileResult {
+    filename: string;
+    passed: boolean;
+    error?: Error;
+}
+export declare function shasumFile(filename: string, root: string | undefined): Promise<string>;
+/**
+ *
+ * @param filename - name of checksum file
+ * @param files - optional list of files to check
+ * @param root - optional root, default cwd.
+ */
+export declare function checkShasumFile(filename: string, files: string[] | undefined, root?: string): Promise<CheckShasumFileResult>;
+export interface ChecksumEntry {
+    filename: string;
+    checksum: string;
+    lineNumber: number;
+}
+export declare function readAndParseShasumFile(filename: string): Promise<ChecksumEntry[]>;
+export declare function parseShasumFile(content: string): ChecksumEntry[];
+interface ReportResult {
+    report: string;
+    passed: boolean;
+}
+interface ReportOptions {
+    root?: string | undefined;
+    listFile?: string[];
+}
+export declare function reportChecksumForFiles(files: string[], options: ReportOptions): Promise<ReportResult>;
+export declare function reportCheckChecksumFile(filename: string, files: string[] | undefined, options: ReportOptions): Promise<ReportResult>;
+export declare function calcUpdateChecksumForFiles(filename: string, files: string[], options: ReportOptions): Promise<string>;
+export declare function updateChecksumForFiles(filename: string, files: string[], options: ReportOptions): Promise<ReportResult>;
+export {};
+//# sourceMappingURL=shasum.d.ts.map

package/dist/shasum/shasum.js

@@ -0,0 +1,148 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve, sep as pathSep } from 'node:path';
+import { toError } from '../util/errors.js';
+import { isDefined } from '../util/index.js';
+import { calcFileChecksum, checkFile } from './checksum.js';
+export async function shasumFile(filename, root) {
+    try {
+        const file = resolve(root || '.', filename);
+        const checksum = await calcFileChecksum(file);
+        return `${checksum}  ${filename}`;
+    }
+    catch (error) {
+        // const err = toError(error);
+        return Promise.reject(`shasum: ${filename}: Unable to read file.`);
+    }
+}
+/**
+ *
+ * @param filename - name of checksum file
+ * @param files - optional list of files to check
+ * @param root - optional root, default cwd.
+ */
+export async function checkShasumFile(filename, files, root) {
+    files = !files ? files : files.length ? files : undefined;
+    const shaFiles = await readAndParseShasumFile(filename);
+    const filesToCheck = !files ? shaFiles.map(({ filename }) => filename) : files;
+    const mapNameToChecksum = new Map(shaFiles.map((r) => [normalizeFilename(r.filename), r.checksum]));
+    const resolvedRoot = resolve(root || '.');
+    const results = await Promise.all(filesToCheck.map(normalizeFilename).map((filename) => {
+        return tryToCheckFile(filename, resolvedRoot, mapNameToChecksum.get(filename));
+    }));
+    const passed = !results.find((v) => !v.passed);
+    return { passed, results };
+}
+async function tryToCheckFile(filename, root, checksum) {
+    if (!checksum) {
+        return { filename, passed: false, error: Error('Missing Checksum.') };
+    }
+    const file = resolve(root, filename);
+    try {
+        const passed = await checkFile(checksum, file);
+        return { filename, passed };
+    }
+    catch (error) {
+        return { filename, passed: false, error: Error('Failed to read file.') };
+    }
+}
+const regLine = /([a-f0-9]{40,}) {2}(.*)/;
+export async function readAndParseShasumFile(filename) {
+    const content = await readFile(resolve(filename), 'utf8');
+    const shaFiles = parseShasumFile(content);
+    return shaFiles;
+}
+export function parseShasumFile(content) {
+    const lines = content.split(/\r?\n|\r/g);
+    return lines.map(parseLine).filter(isDefined);
+    function parseLine(line, index) {
+        const m = line.match(regLine);
+        const lineNumber = index + 1;
+        if (!m) {
+            if (line.trim()) {
+                throw new Error(`Failed to parse line ${lineNumber} of checksum file.`);
+            }
+            return undefined;
+        }
+        const checksum = m[1];
+        const filename = m[2];
+        return { checksum, filename, lineNumber };
+    }
+}
+export async function reportChecksumForFiles(files, options) {
+    const root = options.root;
+    const filesToCheck = await resolveFileList(files, options.listFile);
+    let numFailed = 0;
+    const result = await Promise.all(filesToCheck.map((file) => shasumFile(file, root).catch((e) => {
+        ++numFailed;
+        if (typeof e !== 'string')
+            throw e;
+        return e;
+    })));
+    const report = result.join('\n');
+    const passed = !numFailed;
+    return { report, passed };
+}
+export async function reportCheckChecksumFile(filename, files, options) {
+    const root = options.root;
+    const filesToCheck = await resolveFileList(files, options.listFile);
+    const checkResult = await checkShasumFile(filename, filesToCheck, root);
+    const results = checkResult.results;
+    const lines = results.map(({ filename, passed, error }) => `${filename}: ${passed ? 'OK' : 'FAILED'} ${error ? '- ' + error.message : ''}`.trim());
+    const withErrors = results.filter((a) => !a.passed);
+    const passed = !withErrors.length;
+    if (!passed) {
+        lines.push(`shasum: WARNING: ${withErrors.length} computed checksum${withErrors.length > 1 ? 's' : ''} did NOT match`);
+    }
+    return { report: lines.join('\n'), passed };
+}
+async function resolveFileList(files, listFile) {
+    files = files || [];
+    listFile = listFile || [];
+    const setOfFiles = new Set(files);
+    const pending = listFile.map((filename) => readFile(filename, 'utf8'));
+    for await (const content of pending) {
+        content
+            .split('\n')
+            .map((a) => a.trim())
+            .filter((a) => a)
+            .forEach((file) => setOfFiles.add(file));
+    }
+    return [...setOfFiles].map(normalizeFilename);
+}
+export async function calcUpdateChecksumForFiles(filename, files, options) {
+    const root = options.root || '.';
+    const filesToCheck = await resolveFileList(files, options.listFile);
+    const currentEntries = (await readAndParseShasumFile(filename).catch((err) => {
+        const e = toError(err);
+        if (e.code !== 'ENOENT')
+            throw e;
+        return [];
+    })).map((entry) => ({ ...entry, filename: normalizeFilename(entry.filename) }));
+    const entriesToUpdate = new Set([...filesToCheck, ...currentEntries.map((e) => e.filename)]);
+    const mustExist = new Set(filesToCheck);
+    const checksumMap = new Map(currentEntries.map(({ filename, checksum }) => [filename, checksum]));
+    for (const file of entriesToUpdate) {
+        try {
+            const checksum = await calcFileChecksum(resolve(root, file));
+            checksumMap.set(file, checksum);
+        }
+        catch (e) {
+            if (mustExist.has(file) || toError(e).code !== 'ENOENT')
+                throw e;
+            checksumMap.delete(file);
+        }
+    }
+    const updatedEntries = [...checksumMap]
+        .map(([filename, checksum]) => ({ filename, checksum }))
+        .sort((a, b) => (a.filename < b.filename ? -1 : 1));
+    return updatedEntries.map((e) => `${e.checksum}  ${e.filename}`).join('\n') + '\n';
+}
+export async function updateChecksumForFiles(filename, files, options) {
+    const content = await calcUpdateChecksumForFiles(filename, files, options);
+    await writeFile(filename, content);
+    return { passed: true, report: content };
+}
+function normalizeFilename(filename) {
+    return filename.split(pathSep).join('/');
+}
+//# sourceMappingURL=shasum.js.map

package/dist/test/TestHelper.d.ts

@@ -26,8 +26,6 @@ export interface TestHelper {
      * @param to
      */
     cp(from: string, to: string): void;
-    cd(dir: string): void;
-    cdToTempDir(...parts: string[]): void;
     packageTemp(...parts: string[]): string;
     /**
      * Signal the start of a test.
@@ -38,6 +36,8 @@ export interface TestHelper {
     getCurrentTestName(): string;
     fileExists(path: string): Promise<boolean>;
 }
-export declare function createTestHelper(testFilename?: string): TestHelper;
+export declare function createTestHelper(testFilenameUrl: string): TestHelper;
 export declare function resolvePathToFixture(...segments: string[]): string;
+export declare function test_dirname(importMetaUrl: string): string;
+export declare function test_filename(importMetaUrl: string): string;
 //# sourceMappingURL=TestHelper.d.ts.map

package/dist/test/TestHelper.js

@@ -1,39 +1,18 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePathToFixture = exports.createTestHelper = void 0;
-const fs_1 = require("fs");
-const path = __importStar(require("path"));
-const shell = __importStar(require("shelljs"));
-const packageRoot = path.join(__dirname, '../..');
+import assert from 'assert';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as shell from 'shelljs';
+import { fileURLToPath } from 'url';
+import { expect } from 'vitest';
+const _dirname = test_dirname(import.meta.url);
+const packageRoot = path.join(_dirname, '../..');
 const repoRoot = path.join(packageRoot, '../..');
 const tempDirBase = path.join(packageRoot, 'temp');
-function createTestHelper(testFilename) {
+export function createTestHelper(testFilenameUrl) {
+    testFilenameUrl && assert(testFilenameUrl.startsWith('file:'));
+    const testFilename = testFilenameUrl && test_filename(testFilenameUrl);
     return new TestHelperImpl(testFilename || expect.getState().testPath || 'test');
 }
-exports.createTestHelper = createTestHelper;
 const fixtureDir = path.join(packageRoot, 'fixtures');
 class TestHelperImpl {
     constructor(testFilename) {
@@ -89,20 +68,6 @@ class TestHelperImpl {
     cp(src, dest) {
         shell.cp(this.resolveTemp(src), this.resolveTemp(dest));
     }
-    /**
-     * Change the current directory
-     * @param dir
-     */
-    cd(dir) {
-        shell.cd(this.resolveTemp(dir));
-    }
-    /**
-     * Change dir to temp directory unique to the current test.
-     */
-    cdToTempDir(...parts) {
-        this.createTempDir(...parts);
-        this.cd('.');
-    }
     /**
      * resolve a path to the fixtures.
      * @param parts
@@ -121,7 +86,7 @@ class TestHelperImpl {
     }
     async fileExists(path) {
         try {
-            await fs_1.promises.stat(path);
+            await fs.stat(path);
             return true;
         }
         catch (e) {
@@ -129,8 +94,13 @@ class TestHelperImpl {
         }
     }
 }
-function resolvePathToFixture(...segments) {
+export function resolvePathToFixture(...segments) {
     return path.resolve(fixtureDir, ...segments);
 }
-exports.resolvePathToFixture = resolvePathToFixture;
+export function test_dirname(importMetaUrl) {
+    return path.dirname(test_filename(importMetaUrl));
+}
+export function test_filename(importMetaUrl) {
+    return fileURLToPath(importMetaUrl);
+}
 //# sourceMappingURL=TestHelper.js.map

package/dist/test/console.d.ts

@@ -1,7 +1,4 @@
-/// <reference types="jest" />
 export declare function spyOnConsole(): {
-    log: jest.SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
-    error: jest.SpyInstance<void, [message?: any, ...optionalParams: any[]], any>;
     consoleOutput: () => {
         log: string;
         error: string;

package/dist/test/console.js

@@ -1,11 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.spyOnConsole = void 0;
-const normalizeOutput_1 = require("./normalizeOutput");
-function spyOnConsole() {
+import { vi } from 'vitest';
+import { normalizeOutput } from './normalizeOutput.js';
+export function spyOnConsole() {
     const con = {
-        log: jest.spyOn(console, 'log').mockImplementation(),
-        error: jest.spyOn(console, 'error').mockImplementation(),
+        log: vi.spyOn(console, 'log').mockImplementation(() => undefined),
+        error: vi.spyOn(console, 'error').mockImplementation(() => undefined),
         consoleOutput,
         attach,
         reset,
@@ -14,20 +12,23 @@ function spyOnConsole() {
         const _error = con.error.mock.calls.map((c) => c.join(',')).join('\n');
         const _log = con.log.mock.calls.map((c) => c.join(',')).join('\n');
         return {
-            log: (0, normalizeOutput_1.normalizeOutput)(_log),
-            error: (0, normalizeOutput_1.normalizeOutput)(_error),
+            log: normalizeOutput(_log),
+            error: normalizeOutput(_error),
         };
     }
     function attach() {
         reset();
-        con.log = jest.spyOn(console, 'log').mockImplementation();
-        con.error = jest.spyOn(console, 'error').mockImplementation();
+        con.log = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        con.error = vi.spyOn(console, 'error').mockImplementation(() => undefined);
     }
     function reset() {
         con.log.mockRestore();
         con.error.mockRestore();
     }
-    return con;
+    return {
+        consoleOutput,
+        attach,
+        reset,
+    };
 }
-exports.spyOnConsole = spyOnConsole;
 //# sourceMappingURL=console.js.map

package/dist/test/escapeRegEx.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeRegEx = void 0;
 /**
  * Escape a string so it can be used as an exact match within a RegExp.
  * @param s - string to escape
  * @returns - the escaped string.
  */
-function escapeRegEx(s) {
+export function escapeRegEx(s) {
     return s.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
 }
-exports.escapeRegEx = escapeRegEx;
 //# sourceMappingURL=escapeRegEx.js.map

package/dist/test/normalizeOutput.js

@@ -1,46 +1,20 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeDirectorySeparator = exports.normalizeOutput = void 0;
-const path = __importStar(require("path"));
-const escapeRegEx_1 = require("./escapeRegEx");
-const rootCspellTools = path.join(__dirname, '../..');
+import * as path from 'path';
+import { escapeRegEx } from './escapeRegEx.js';
+import { test_dirname } from './TestHelper.js';
+const _dirname = test_dirname(import.meta.url);
+const rootCspellTools = path.join(_dirname, '../..');
 const rootRepo = path.join(rootCspellTools, '../..');
 /**
  * Example: `2022-10-02T17:10:04.681Z`
  */
 const regexpDate = /\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(\.\d+)?Z/gi;
-const rxRootRepo = new RegExp((0, escapeRegEx_1.escapeRegEx)(rootRepo) + '|' + (0, escapeRegEx_1.escapeRegEx)(normalizeDirectorySeparator(rootRepo)), 'gi');
-function normalizeOutput(output, cwd = process.cwd()) {
-    const rxCwd = new RegExp((0, escapeRegEx_1.escapeRegEx)(cwd) + '|' + (0, escapeRegEx_1.escapeRegEx)(normalizeDirectorySeparator(cwd)), 'gi');
+const rxRootRepo = new RegExp(escapeRegEx(rootRepo) + '|' + escapeRegEx(normalizeDirectorySeparator(rootRepo)), 'gi');
+export function normalizeOutput(output, cwd = process.cwd()) {
+    const rxCwd = new RegExp(escapeRegEx(cwd) + '|' + escapeRegEx(normalizeDirectorySeparator(cwd)), 'gi');
     const normalizeDirs = normalizeDirectorySeparator(output.replace(rxCwd, '{cwd}').replace(rxRootRepo, '{repo-root}'));
     return normalizeDirs.replace(regexpDate, '2022-01-01T00:00:00.000Z');
 }
-exports.normalizeOutput = normalizeOutput;
-function normalizeDirectorySeparator(path) {
+export function normalizeDirectorySeparator(path) {
     return path.replace(/\\/g, '/');
 }
-exports.normalizeDirectorySeparator = normalizeDirectorySeparator;
 //# sourceMappingURL=normalizeOutput.js.map

package/dist/util/errors.d.ts

@@ -0,0 +1,6 @@
+export interface NodeError extends Error {
+    code?: string;
+}
+export declare function toError(err: unknown): NodeError;
+export declare function isError(err: unknown): err is Error;
+//# sourceMappingURL=errors.d.ts.map

package/dist/util/errors.js

@@ -0,0 +1,11 @@
+export function toError(err) {
+    if (isError(err))
+        return err;
+    return new Error(`${err}`);
+}
+export function isError(err) {
+    if (err instanceof Error)
+        return true;
+    return false;
+}
+//# sourceMappingURL=errors.js.map

package/dist/util/globP.d.ts

@@ -0,0 +1,7 @@
+interface Options {
+    cwd?: string | URL;
+    nodir?: boolean;
+}
+export declare function globP(pattern: string | string[], options?: Options): Promise<string[]>;
+export {};
+//# sourceMappingURL=globP.d.ts.map

package/dist/util/globP.js

@@ -0,0 +1,7 @@
+import { glob } from 'glob';
+export function globP(pattern, options) {
+    // Convert windows separators.
+    const globs = (Array.isArray(pattern) ? pattern : [pattern]).map((pattern) => pattern.replace(/\\/g, '/'));
+    return glob(globs, options);
+}
+//# sourceMappingURL=globP.js.map

package/dist/util/index.d.ts

@@ -0,0 +1,2 @@
+export declare function isDefined<T>(a: T | undefined | null): a is T;
+//# sourceMappingURL=index.d.ts.map

package/dist/util/index.js

@@ -0,0 +1,4 @@
+export function isDefined(a) {
+    return !!a || (a !== null && a !== undefined);
+}
+//# sourceMappingURL=index.js.map