@zokugun/artifact 0.5.2 → 0.6.1

package/lib/utils/command/split-command.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitCommand = splitCommand;
-const lodash_1 = require("lodash");
+const lodash_es_1 = require("lodash-es");
 function splitCommand(command) {
     const result = {};
-    const splitted = command.split(/([&|]{1,2}|;)/).map(lodash_1.trim);
+    const splitted = command.split(/([&|]{1,2}|;)/).map(lodash_es_1.trim);
     for (let i = 0; i < splitted.length; i++) {
         const command = splitted[i];
-        const splittedSubcommand = command.split(/([\w-]+=\S+)\s/).filter(lodash_1.identity);
+        const splittedSubcommand = command.split(/([\w-]+=\S+)\s/).filter(lodash_es_1.identity);
         if (splittedSubcommand.length > 0) {
-            const subcommandWithArgs = (0, lodash_1.last)(splittedSubcommand).split(' ');
-            const subcommand = (0, lodash_1.head)(subcommandWithArgs).trim();
+            const subcommandWithArgs = (0, lodash_es_1.last)(splittedSubcommand).split(' ');
+            const subcommand = (0, lodash_es_1.head)(subcommandWithArgs).trim();
             const args = subcommandWithArgs.slice(1);
-            const env = splittedSubcommand.slice(0, -1);
+            const environment = splittedSubcommand.slice(0, -1);
             const parsedSubcommand = {
-                args: args.map(lodash_1.trim),
-                env: env.map(lodash_1.trim),
+                args: args.map(lodash_es_1.trim),
+                env: environment.map(lodash_es_1.trim),
                 separator: splitted[i + 1],
             };
             if (result[subcommand]) {

package/lib/utils/command/split-prefix-and-flags.d.ts

@@ -0,0 +1,4 @@
+export declare function splitPrefixAndFlags(command: string): {
+    prefix: string;
+    flags: string[];
+};

package/lib/utils/command/split-prefix-and-flags.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitPrefixAndFlags = splitPrefixAndFlags;
 function splitPrefixAndFlags(command) {
     const tokens = command.split(/\s+/).filter(Boolean);
-    let idx = tokens.findIndex((t) => t.startsWith('-'));
-    if (idx === -1) {
-        idx = tokens.length;
+    let index = tokens.findIndex((t) => t.startsWith('-'));
+    if (index === -1) {
+        index = tokens.length;
     }
-    const prefix = tokens.slice(0, idx).join(' ');
-    const rest = tokens.slice(idx);
+    const prefix = tokens.slice(0, index).join(' ');
+    const rest = tokens.slice(index);
     const flags = [];
     for (let i = 0; i < rest.length; i++) {
         const t = rest[i];

package/lib/utils/command/split-segments.d.ts

@@ -0,0 +1 @@
+export declare function splitSegments(s: string): string[];

package/lib/utils/detect-indent.d.ts

@@ -0,0 +1,2 @@
+import { type Indent } from '../types/format.js';
+export declare function detectIndent(text: string): Indent | undefined;

package/lib/utils/detect-indent.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectIndent = detectIndent;
+const format_js_1 = require("../types/format.js");
+const INDENT_REGEX = /^(?:(\t+)|( +))/;
+const LINE_SEPARATOR_REGEX = /\r\n|\r|\n/;
+function detectIndent(text) {
+    const lines = text.split(LINE_SEPARATOR_REGEX);
+    const indentations = new Set();
+    let spaces = 0;
+    let tabs = 0;
+    for (const line of lines) {
+        const match = INDENT_REGEX.exec(line);
+        if (match) {
+            if (match[1]) {
+                tabs += 1;
+            }
+            else {
+                indentations.add(match[2].length);
+                spaces += 1;
+            }
+        }
+    }
+    if (tabs > spaces) {
+        return {
+            style: format_js_1.IndentStyle.TAB,
+            size: 1,
+        };
+    }
+    if (indentations.size === 0) {
+        return undefined;
+    }
+    const sorted = [...indentations].sort((a, b) => a - b);
+    const diffs = [];
+    for (let i = 1; i < sorted.length; i++) {
+        const d = sorted[i] - sorted[i - 1];
+        if (d > 0) {
+            diffs.push(d);
+        }
+    }
+    let size = sorted[0];
+    if (diffs.length > 0) {
+        size = diffs.shift();
+        for (const value of diffs) {
+            size = gcd(size, value);
+        }
+    }
+    if (!size || size === 0) {
+        size = sorted[0];
+    }
+    return {
+        style: format_js_1.IndentStyle.SPACE,
+        size,
+    };
+}
+function gcd(a, b) {
+    while (b !== 0) {
+        const t = a % b;
+        a = b;
+        b = t;
+    }
+    return Math.abs(a);
+} // }}}

package/lib/utils/flow.d.ts

@@ -0,0 +1,3 @@
+type AnyFn = (input: any) => unknown | Promise<unknown>;
+export declare function flow<Args = unknown, Result = unknown>(...functions: AnyFn[]): (args: Args) => Promise<Result>;
+export {};

package/lib/utils/flow.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flow = flow;
+function flow(...functions) {
+    return async (args) => {
+        let result = args;
+        for (const fn of functions) {
+            result = await fn(result);
+        }
+        return result;
+    };
+}

package/lib/utils/get-format.d.ts

@@ -0,0 +1,2 @@
+import type { Format } from '../types/format.js';
+export declare function getFormat(name: string, formats: Format[]): Format | null;

package/lib/utils/get-format.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFormat = getFormat;
+const fnmatch_1 = __importDefault(require("editorconfig/src/lib/fnmatch"));
+function fnmatch(filepath, glob) {
+    const matchOptions = { matchBase: true, dot: true, noext: true };
+    return (0, fnmatch_1.default)(filepath, glob, matchOptions);
+} // }}}
+function getFormat(name, formats) {
+    for (const format of formats) {
+        if (fnmatch(name, format.glob)) {
+            return format;
+        }
+    }
+    return null;
+}

package/lib/utils/has-final-new-line.d.ts

@@ -0,0 +1 @@
+export declare function hasFinalNewLine(text: string): boolean;

package/lib/utils/has-final-new-line.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasFinalNewLine = hasFinalNewLine;
+const FINAL_LINE_REGEX = /\r\n|\r|\n$/;
+function hasFinalNewLine(text) {
+    return FINAL_LINE_REGEX.test(text);
+}

package/lib/utils/read-buffer.d.ts

@@ -0,0 +1,2 @@
+import { Buffer } from 'buffer';
+export declare function readBuffer(filepath: string, size: number, offset?: number): Promise<Buffer>;

package/lib/utils/resolve-request.d.ts

@@ -0,0 +1,3 @@
+import { type DResult } from '@zokugun/xtry';
+import { type Request } from '../types/config.js';
+export declare function resolveRequest(spec: string): DResult<Request>;

package/lib/utils/resolve-request.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveRequest = resolveRequest;
+const xtry_1 = require("@zokugun/xtry");
 const untildify_1 = __importDefault(require("untildify"));
 function resolveRequest(spec) {
     if (spec.startsWith('~')) {
@@ -32,11 +33,11 @@ function resolveRequest(spec) {
     if (spec.includes(':')) {
         const [name, variant] = spec.split(':');
         if (variant.length === 0) {
-            throw new Error(`Missing variant in "${spec}"`);
+            return (0, xtry_1.err)(`Missing variant in "${spec}"`);
         }
-        return { name, variant };
+        return (0, xtry_1.ok)({ name, variant });
     }
     else {
-        return { name: spec };
+        return (0, xtry_1.ok)({ name: spec });
     }
 } // }}}

package/lib/utils/template.d.ts

@@ -0,0 +1,17 @@
+import { type DResult } from '@zokugun/xtry';
+export declare class TemplateEngine {
+    private readonly basePath;
+    private readonly fileCache;
+    private readonly variables;
+    private readonly variableCache;
+    constructor(basePath: string, variables?: Record<string, string>);
+    render(template: string): DResult<string>;
+    private getValueByPath;
+    private parseFile;
+    private readConfigFile;
+    private resolveExpression;
+    private resolveVariable;
+    private splitPlaceholder;
+    private toDate;
+}
+export declare function unescapeCode(code: string): string;

package/lib/utils/template.js

@@ -39,92 +39,105 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TemplateEngine = void 0;
 exports.unescapeCode = unescapeCode;
 const path_1 = __importDefault(require("path"));
+const sync_1 = __importDefault(require("@zokugun/fs-extra-plus/sync"));
+const xtry_1 = require("@zokugun/xtry");
 const dayjs_1 = __importDefault(require("dayjs"));
 const utc_1 = __importDefault(require("dayjs/plugin/utc"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const lodash_1 = require("lodash");
-const YAML = __importStar(require("../parsers/yaml"));
-const try_json_1 = require("./try-json");
+const lodash_es_1 = require("lodash-es");
+const YAML = __importStar(require("../parsers/yaml.js"));
+const try_json_js_1 = require("./try-json.js");
 dayjs_1.default.extend(utc_1.default);
+const EXPRESSION_REGEX = /#\[\[(.*?)]]/g;
 const NEXT_PROPERTY_REGEX = /^(\w+?)((?=\.|$).*)$/;
 const PLACEHOLDER_REGEX = /^((?:[^/.]+(?:[^/]+\/)*\/)?\.?[^.]+(?:\.(?:json|ya?ml))?)\.(.*)$/;
-class TemplateError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'TemplateError';
-    } // }}}
-}
 class TemplateEngine {
+    basePath;
+    fileCache = new Map();
+    variables;
+    variableCache = new Map();
     constructor(basePath, variables) {
-        this.fileCache = new Map();
-        this.variableCache = new Map();
         this.basePath = basePath;
         this.variables = variables ?? {};
     } // }}}
     render(template) {
-        const pattern = /#\[\[(.*?)]]/g;
-        return template.replace(pattern, (_, placeholder) => this.resolveExpression(placeholder));
+        let content = '';
+        let lastIndex = 0;
+        let match;
+        while ((match = EXPRESSION_REGEX.exec(template))) {
+            const result = this.resolveExpression(match[1]);
+            if (result.fails) {
+                return result;
+            }
+            content += template.slice(lastIndex, match.index) + result.value;
+            lastIndex = EXPRESSION_REGEX.lastIndex;
+        }
+        content += template.slice(lastIndex);
+        return (0, xtry_1.ok)(content);
     } // }}}
     getValueByPath(values, propertyPath) {
         let currentPath = propertyPath;
         let currentValue = values;
-        // eslint-disable-next-line @typescript-eslint/ban-types
         let match;
         while ((match = NEXT_PROPERTY_REGEX.exec(currentPath))) {
-            if (!(0, lodash_1.isPlainObject)(currentValue)) {
-                throw new TemplateError(`Property path not found: ${propertyPath}`);
+            if (!(0, lodash_es_1.isPlainObject)(currentValue)) {
+                return (0, xtry_1.err)(`Property path not found: ${propertyPath}`);
             }
             currentValue = currentValue[match[1]];
-            if ((0, lodash_1.isNil)(currentValue)) {
-                throw new TemplateError(`Property not found: ${propertyPath}`);
+            if ((0, lodash_es_1.isNil)(currentValue)) {
+                return (0, xtry_1.err)(`Property not found: ${propertyPath}`);
             }
             currentPath = match[2];
             if (currentPath.length === 0) {
-                return currentValue;
+                return (0, xtry_1.ok)(currentValue);
             }
         }
         // eslint-disable-next-line no-new-func
         const fn = new Function('it', `return it${unescapeCode(currentPath)};`);
-        return fn(currentValue);
+        return (0, xtry_1.ok)(fn(currentValue));
     } // }}}
     parseFile(filename) {
-        let content;
-        try {
-            content = fs_extra_1.default.readFileSync(filename, 'utf8');
-        }
-        catch {
-            throw new TemplateError(`File not found: ${filename}`);
+        const result = sync_1.default.readFile(filename, 'utf8');
+        if (result.fails) {
+            return (0, xtry_1.err)(`TemplateError: File not found: ${filename}`);
         }
-        const ext = path_1.default.extname(filename).toLowerCase();
+        const content = result.value;
+        const extension = path_1.default.extname(filename).toLowerCase();
         try {
-            if (ext === '.json') {
-                return JSON.parse(content);
+            if (extension === '.json') {
+                return (0, xtry_1.ok)(JSON.parse(content));
             }
-            else if (ext === '.yaml' || ext === '.yml') {
-                return YAML.parse(content);
+            else if (extension === '.yaml' || extension === '.yml') {
+                return (0, xtry_1.ok)(YAML.parse(content));
             }
             else {
-                return (0, try_json_1.tryJson)(content) ?? YAML.parse(content);
+                return (0, xtry_1.ok)((0, try_json_js_1.tryJSON)(content) ?? YAML.parse(content));
             }
         }
         catch (parseError) {
-            throw new TemplateError(`Failed to parse ${filename}: ${parseError.message}`);
+            return (0, xtry_1.err)(`Failed to parse ${filename}: ${parseError.message}`);
         }
     } // }}}
     readConfigFile(filename) {
         // Check cache first
         if (this.fileCache.has(filename)) {
-            return this.fileCache.get(filename);
+            return (0, xtry_1.ok)(this.fileCache.get(filename));
         }
         const filePath = path_1.default.resolve(this.basePath, filename);
-        const content = this.parseFile(filePath);
-        this.fileCache.set(filename, content);
-        return content;
+        const result = this.parseFile(filePath);
+        if (result.fails) {
+            return result;
+        }
+        this.fileCache.set(filename, result.value);
+        return result;
     } // }}}
     resolveExpression(expression) {
-        const [name, propertyPath] = this.splitPlaceholder(expression);
+        const result = this.splitPlaceholder(expression);
+        if (result.fails) {
+            return result;
+        }
+        const { name, propertyPath } = result.value;
         if (!name || !propertyPath) {
-            throw new TemplateError(`Invalid expression format: ${expression}. Expected format: #[[filename.property]]`);
+            return (0, xtry_1.err)(`Invalid expression format: ${expression}. Expected format: #[[filename.property]]`);
         }
         if (name === 'date') {
             return this.toDate(propertyPath);
@@ -133,48 +146,57 @@ class TemplateEngine {
             return this.resolveVariable(propertyPath);
         }
         else {
-            const fileContent = this.readConfigFile(name);
-            const value = this.getValueByPath(fileContent, propertyPath);
-            if ((0, lodash_1.isNil)(value)) {
-                throw new TemplateError(expression);
+            const readResult = this.readConfigFile(name);
+            if (readResult.fails) {
+                return readResult;
+            }
+            const getValueResult = this.getValueByPath(readResult.value, propertyPath);
+            if (getValueResult.fails) {
+                return getValueResult;
             }
-            return String(value);
+            if ((0, lodash_es_1.isNil)(getValueResult.value)) {
+                return (0, xtry_1.err)(expression);
+            }
+            return (0, xtry_1.ok)(String(getValueResult.value));
         }
     } // }}}
     resolveVariable(name) {
         if (this.variableCache.has(name)) {
-            return this.variableCache.get(name);
+            return (0, xtry_1.ok)(this.variableCache.get(name));
         }
         const expression = this.variables[name];
         if (typeof expression !== 'string' || expression.trim().length === 0) {
-            throw new TemplateError(`Invalid variable: ${name}.`);
+            return (0, xtry_1.err)(`Invalid variable: ${name}.`);
+        }
+        const result = this.resolveExpression(expression);
+        if (result.fails) {
+            return result;
         }
-        const content = this.resolveExpression(expression);
-        this.variableCache.set(name, content);
-        return content;
+        this.variableCache.set(name, result.value);
+        return result;
     } // }}}
     splitPlaceholder(placeholder) {
         const matches = PLACEHOLDER_REGEX.exec(placeholder);
         if (!matches) {
-            throw new TemplateError(`Invalid expression format: ${placeholder}. Expected format: #[[filename.property]]`);
+            return (0, xtry_1.err)(`Invalid expression format: ${placeholder}. Expected format: #[[filename.property]]`);
         }
-        const [, filename, propertyPath] = matches;
-        return [filename, propertyPath];
+        const [, name, propertyPath] = matches;
+        return (0, xtry_1.ok)({ name, propertyPath });
     } // }}}
     toDate(format) {
         try {
             const now = (0, dayjs_1.default)().utc();
             if (format === 'utc') {
-                return now.format('YYYY-MM-DD HH:mm:ss');
+                return (0, xtry_1.ok)(now.format('YYYY-MM-DD HH:mm:ss'));
             }
-            return now.format(format);
+            return (0, xtry_1.ok)(now.format(format));
         }
         catch {
-            throw new TemplateError(`Invalid date format: ${format}`);
+            return (0, xtry_1.err)(`Invalid date format: ${format}`);
         }
     } // }}}
 }
 exports.TemplateEngine = TemplateEngine;
 function unescapeCode(code) {
-    return code.replace(/\\('|\\)/g, '$1').replace(/[\r\t\n]/g, ' ');
+    return code.replaceAll(/\\('|\\)/g, '$1').replaceAll(/[\r\t\n]/g, ' ');
 }

package/lib/utils/to-lines.d.ts

@@ -0,0 +1 @@
+export declare function toLines(value: string): string[];

package/lib/utils/trim-final-newline.d.ts

@@ -0,0 +1 @@
+export declare function trimFinalNewLine(value: string): string;

package/lib/utils/try-json.d.ts

@@ -0,0 +1 @@
+export declare function tryJSON(value: string): Record<string, unknown> | undefined;

package/lib/utils/try-json.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryJson = tryJson;
-function tryJson(value) {
+exports.tryJSON = tryJSON;
+function tryJSON(value) {
     try {
         return JSON.parse(value);
     }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/artifact",
 	"description": "Boilerplate your project & keep your configurations up to date",
-	"version": "0.5.2",
+	"version": "0.6.1",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"
@@ -13,76 +13,99 @@
 		"url": "https://github.com/zokugun/artifact.git"
 	},
 	"bugs": {
-		"url": "https://github.com/zokugun/artifact/issues"
+		"url": "https://github.com/zokugun/artifact/discussions/categories/issue-triage"
+	},
+	"engines": {
+		"node": ">=18.20"
 	},
 	"bin": {
 		"artifact": "bin/artifact",
 		"atf": "bin/artifact"
 	},
 	"scripts": {
-		"compile": "tsc -p src",
+		"audit:fix": "npm audit fix --min-release-age=0",
+		"build": "npm run clean && npm run compile:src",
+		"ci:lint": "zizmor .",
+		"ci:lint:fix": "zizmor . --fix=all",
+		"clean": "rimraf .test lib",
+		"compile:src": "tsc -p src",
 		"lint": "xo",
-		"prepare": "husky install;",
-		"prepublishOnly": "npm run compile",
+		"lint:all": "fixpack && npm run ci:lint && npm run lint",
+		"lint:fix": "xo --fix",
+		"prepack": "npm run build",
+		"prepare": "husky; fixpack || true",
 		"release": "release-it",
 		"test": "tsc -p test && mocha",
 		"test:dev": "mocha",
 		"test:watch": "tsc-watch -p src -p test --onSuccess 'mocha -g=\"\"'",
+		"update:artifacts": "artifact update",
+		"update:ci": "PINACT_MIN_AGE=7 pinact run",
+		"update:deps": "taze",
+		"watch:build": "tsc-watch -p src --onSuccess 'npm run build'",
 		"watch:src": "tsc-watch -p src",
 		"watch:test": "tsc-watch -p test"
 	},
 	"dependencies": {
-		"@zokugun/cli-utils": "^0.2.0",
-		"@zokugun/configdotts-merge": "^0.2.0",
-		"ansi-colors": "^4.1.1",
-		"dayjs": "^1.11.13",
-		"detect-indent": "^6.1.0",
-		"editorconfig": "^0.15.3",
-		"fs-extra": "^10.0.0",
-		"globby": "^11.0.4",
-		"istextorbinary": "^6.0.0",
-		"jsonc-parser": "^3.0.0",
-		"lodash": "^4.18.1",
-		"micromatch": "^4.0.8",
-		"npm": "^7.23.0",
-		"ora": "^5.4.1",
-		"pacote": "^13.0.5",
-		"semver": "^7.7.4",
-		"tempy": "^1.0.1",
-		"typescript": "^5.9.2",
-		"untildify": "^4.0.0",
+		"@zokugun/cli-utils": "0.3.1",
+		"@zokugun/configdotts-merge": "0.2.1",
+		"@zokugun/fs-extra-plus": "0.3.7",
+		"@zokugun/is-it-type": "0.8.1",
+		"@zokugun/xtry": "0.11.4",
+		"dayjs": "1.11.20",
+		"editorconfig": "0.15.3",
+		"globby": "11.1.0",
+		"istextorbinary": "6.0.0",
+		"jq-wasm": "1.1.0-jq-1.8.1",
+		"jsonc-parser": "3.3.1",
+		"lodash-es": "4.18.1",
+		"micromatch": "4.0.8",
+		"pacote": "21.5.0",
+		"semver": "7.7.4",
+		"tempy": "1.0.1",
+		"untildify": "4.0.0",
 		"yaml": "2.8.3"
 	},
 	"devDependencies": {
-		"@commitlint/cli": "^16.2.3",
-		"@commitlint/config-conventional": "^16.2.1",
-		"@types/chai": "^4.2.17",
-		"@types/chai-as-promised": "^7.1.4",
-		"@types/fs-extra": "^9.0.12",
-		"@types/lodash": "^4.14.172",
-		"@types/micromatch": "^4.0.2",
-		"@types/mocha": "^9.0.0",
+		"@commitlint/cli": "19.8.1",
+		"@commitlint/config-conventional": "19.8.1",
+		"@types/chai": "4.3.20",
+		"@types/chai-as-promised": "7.1.8",
+		"@types/lodash-es": "4.17.12",
+		"@types/micromatch": "4.0.10",
+		"@types/mocha": "9.1.1",
 		"@types/node": "20.19.39",
-		"@types/npm": "^7.19.0",
-		"@types/pacote": "^11.1.1",
-		"@types/semver": "^7.3.8",
-		"@types/universalify": "^1.0.0",
-		"camelcase": "^6.2.0",
-		"chai": "^4.3.4",
-		"chai-as-promised": "^7.1.1",
+		"@types/npm": "7.19.3",
+		"@types/pacote": "11.1.8",
+		"@types/semver": "7.7.1",
+		"@types/universalify": "1.0.3",
+		"camelcase": "6.3.0",
+		"chai": "4.5.0",
+		"chai-as-promised": "7.1.2",
 		"eslint": "8.11.0",
-		"eslint-plugin-chai-friendly": "^0.7.2",
-		"fixpack": "^4.0.0",
-		"husky": "^7.0.1",
-		"lint-staged": "^12.3.6",
-		"memfs": "^3.2.4",
-		"mocha": "^9.1.1",
-		"release-it": "^14.11.3",
-		"rewiremock": "^3.14.3",
-		"source-map-support": "^0.5.20",
-		"tsc-watch": "^4.5.0",
-		"universalify": "^2.0.0",
-		"xo": "^0.48.0"
+		"eslint-plugin-chai-friendly": "0.7.4",
+		"fixpack": "4.0.0",
+		"husky": "9.1.7",
+		"lint-staged": "16.4.0",
+		"memfs": "3.6.0",
+		"mocha": "9.2.2",
+		"release-it": "20.0.0",
+		"rewiremock": "3.14.6",
+		"source-map-support": "0.5.21",
+		"taze": "19.11.0",
+		"tsc-watch": "7.2.0",
+		"typescript": "5.9.3",
+		"universalify": "2.0.1",
+		"xo": "0.60.0"
+	},
+	"overrides": {
+		"mocha": {
+			"diff": "5.2.2",
+			"glob": "8.1.0",
+			"js-yaml": "4.1.1",
+			"minimatch": "4.2.6",
+			"nanoid": "3.3.11",
+			"serialize-javascript": "7.0.5"
+		}
 	},
 	"keywords": [
 		"artifact",

package/lib/types/text-file.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/dev-null.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDevNull = createDevNull;
-const fs_1 = require("fs");
-function createDevNull() {
-    return (0, fs_1.createWriteStream)('/dev/null');
-}