prodex 1.1.0 → 1.3.0

package/dist/cli/summary.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.endSummary = endSummary;
+exports.introSummary = introSummary;
+exports.entrySummary = entrySummary;
+const logger_1 = require("../lib/logger");
+const helpers_1 = require("../core/helpers");
+function endSummary(out, result) {
+    logger_1.logger.debug(`🧩 Summary:
+ • Unique imports expected: ${result.stats.expected.size}
+ • Unique imports resolved: ${result.stats.resolved.size}
+`);
+    logger_1.logger.log(`✅ ${out.norm()}`);
+}
+function introSummary({ flags, config }) {
+    logger_1.logger.log(`------- PRODEx RUN @ ${new Date().toLocaleTimeString()} — Codebase decoded -------`);
+    // Log parse results for testing
+    logger_1.logger.debug("🧩 Parsed CLI input:", _2j({ flags }));
+    logger_1.logger.debug("Final merged config:", _2j(config));
+}
+function entrySummary(entries) {
+    let result = "📋 You selected:";
+    for (const e of entries)
+        result += "\n   -" + (0, helpers_1.rel)(e);
+    logger_1.logger.log(result);
+}

package/dist/constants/config-loader.js

@@ -0,0 +1,95 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadProdexConfig = loadProdexConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const default_config_1 = require("./default-config");
+const logger_1 = require("../lib/logger");
+const utils_1 = require("../lib/utils");
+/**
+ * 🧩 Load and merge Prodex configuration (v3)
+ *
+ * 1️⃣ Reads `prodex.json` if present.
+ * 2️⃣ Merges with `DEFAULT_PRODEX_CONFIG`.
+ * 3️⃣ Normalizes all path-like fields.
+ * 4️⃣ Applies CLI flag overrides.
+ */
+async function loadProdexConfig(flags = {}, cwd) {
+    const configPath = path_1.default.join(cwd, "prodex.json");
+    let userConfig = {};
+    // 1️⃣ Load config if present
+    try {
+        const content = fs_1.default.readFileSync(configPath, "utf8");
+        userConfig = JSON.parse(content);
+    }
+    catch (err) {
+        logger_1.logger.info("No prodex.json found — using defaults.");
+    }
+    // 2️⃣ Merge defaults → user config
+    const { output, entry, resolve } = default_config_1.DEFAULT_PRODEX_CONFIG;
+    const cfg = {
+        ...default_config_1.DEFAULT_PRODEX_CONFIG,
+        ...userConfig,
+        output: { ...output, ...userConfig.output },
+        entry: {
+            ...entry,
+            ...userConfig.entry,
+            ui: { ...entry.ui, ...userConfig.entry?.ui },
+        },
+        resolve: { ...resolve, ...userConfig.resolve },
+        root: cwd,
+        name: flags?.name,
+    };
+    // 4️⃣ Apply CLI flag overrides (if any)
+    applyFlagOverrides(cfg, flags);
+    tidyArrayFields(cfg);
+    return cfg;
+}
+/** Merge CLI flags into config where relevant. */
+/** Merge CLI flags into config where relevant. */
+function applyFlagOverrides(cfg, flags) {
+    if (!flags)
+        return;
+    const outputOverrides = {
+        txt: (cfg, v) => (cfg.output.format = v ? "txt" : "md"),
+    };
+    const resolveOverrides = {
+        limit: (cfg, v) => (cfg.resolve.limit = v),
+        include: (cfg, v) => (cfg.resolve.include = v),
+        exclude: (cfg, v) => (cfg.resolve.exclude = v),
+    };
+    const entryOverrides = {
+        files: (cfg, v) => (cfg.entry.files = v),
+    };
+    const envOverrides = {
+        debug: (_, v) => (process.env.PRODEX_DEBUG = v ? "1" : "0"),
+        verbose: (_, v) => (process.env.PRODEX_VERBOSE = v ? "1" : "0"),
+    };
+    const overrideMap = {
+        ...outputOverrides,
+        ...resolveOverrides,
+        ...entryOverrides,
+        ...envOverrides,
+    };
+    // Apply all flag overrides dynamically
+    for (const [flag, value] of Object.entries(flags)) {
+        if (value == undefined)
+            continue;
+        const apply = overrideMap[flag];
+        if (apply)
+            apply(cfg, value);
+    }
+    // Conditional override rule:
+    // If files exist and include was null/undefined → clear include array
+    const hasFiles = Array.isArray(flags.files) ? flags.files.length > 0 : !!flags.files;
+    if (hasFiles && !flags.include) {
+        cfg.resolve.include = [];
+    }
+}
+function tidyArrayFields(cfg) {
+    cfg.entry.files = (0, utils_1.normalizePatterns)(cfg.entry.files);
+    ["include", "exclude"].forEach((k) => (cfg.resolve[k] = cfg.resolve[k]));
+}

package/dist/constants/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_GLOB_CHARS = exports.SUFFIX = exports.DTS_EXT = exports.BASE_EXTS = exports.GLOBAL_IGNORE = exports.RESOLVERS = exports.CODE_EXTS = void 0;
+exports.CODE_EXTS = [".js", ".mjs", ".ts", ".tsx", ".d.ts", ".php"];
+const js_resolver_1 = require("../resolvers/js/js-resolver");
+const php_resolver_1 = require("../resolvers/php/php-resolver");
+exports.RESOLVERS = {
+    ".php": php_resolver_1.resolvePhpImports,
+    ".ts": js_resolver_1.resolveJsImports,
+    ".tsx": js_resolver_1.resolveJsImports,
+    ".d.ts": js_resolver_1.resolveJsImports,
+    ".js": js_resolver_1.resolveJsImports,
+};
+exports.GLOBAL_IGNORE = ["**/node_modules/**", "**/vendor/**", "**/dist/**"];
+exports.BASE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".types"];
+exports.DTS_EXT = ".d.ts";
+exports.SUFFIX = "trace";
+/**
+ * Normalize and sanitize pattern fields.
+ * - Always returns an array.
+ * - Accepts string or string[].
+ * - Splits comma-separated strings.
+ * - Trims and removes empty elements.
+ * - Filters out invalid or unusable characters for Fast-Glob.
+ */
+exports.VALID_GLOB_CHARS = /^[\w\-@./*?|!{}\[\]^$()+]+$/; // allows Fast-Glob-safe symbols

package/dist/constants/default-config.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRODEX_CONFIG = void 0;
+/**
+ * Default configuration for Prodex.
+ * Conforms strictly to ProdexConfig for full type safety.
+ */
+exports.DEFAULT_PRODEX_CONFIG = {
+    version: 3.1,
+    output: {
+        dir: "prodex",
+        versioned: true,
+        prefix: "combined",
+        format: "md",
+    },
+    entry: {
+        files: [],
+        ui: {
+            roots: ["app", "routes", "resources/js/**"],
+            scanDepth: 2,
+            priority: ["**/routes/web.php", "**/routes/api.php", "**/*index.*", "**/*main.*", "**/app.*"],
+        },
+    },
+    resolve: {
+        include: ["**/*.d.ts", "**/*.interface.ts"],
+        aliases: {
+            "@hooks": "resources/js/hooks",
+            "@data": "resources/js/data",
+        },
+        exclude: ["node_modules/**", "@shadcn/**", "**/components/ui/**"],
+        depth: 10,
+        limit: 200,
+    },
+};

package/dist/constants/render-constants.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MD_FOOTER = exports.TEXT_HEADERS = exports.LANG_MAP = void 0;
+// ================================================================
+// 🧩 Prodex — Render Constants
+// Defines shared constants for renderer outDir formats.
+// ================================================================
+const package_json_1 = __importDefault(require("../../package.json"));
+exports.LANG_MAP = {
+    "": "js",
+    ".mjs": "js",
+    ".jsx": "jsx",
+    ".ts": "ts",
+    ".tsx": "tsx",
+    ".php": "php",
+    ".json": "json",
+    ".d.ts": "ts",
+};
+exports.TEXT_HEADERS = {
+    toc: "##==== Combined Scope ====",
+    path: (p) => `##==== path: ${p} ====`,
+    regionStart: (p) => `##region ${p}`,
+    regionEnd: "##endregion",
+};
+exports.MD_FOOTER = ["\n---", "*Generated with [Prodex](https://github.com/emxhive/prodex) — Codebase decoded.*", `<!-- PRODEx v${package_json_1.default.version} | ${new Date().toISOString()} -->`].join("\n");

package/dist/core/combine.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCombine = runCombine;
+const picker_1 = require("../cli/picker");
+const summary_1 = require("../cli/summary");
+const dependency_1 = require("./dependency");
+const file_utils_1 = require("./file-utils");
+const logger_1 = require("../lib/logger");
+const output_1 = require("./output");
+async function runCombine({ cfg, opts }) {
+    const { showUi, cliName } = opts;
+    let entries = (await resolveEntries(showUi, cfg)) ?? [];
+    if (!entries.length) {
+        logger_1.logger.error("No entries selected.");
+        return;
+    }
+    (0, summary_1.entrySummary)(entries);
+    const result = await (0, dependency_1.followChain)(entries, cfg);
+    const withinclude = await (0, dependency_1.applyincludes)(cfg, result.files);
+    const autoName = (0, file_utils_1.produceSmartName)(entries);
+    const outputPath = await (0, output_1.produceOutput)({ name: cliName ?? autoName, files: withinclude, cfg, showUi });
+    (0, summary_1.endSummary)(outputPath, result);
+}
+async function resolveEntries(showUi, cfg) {
+    const { root, entry } = cfg;
+    const { files } = entry;
+    if (!showUi) {
+        logger_1.logger.info("CI Mode");
+        if (!files?.length) {
+            logger_1.logger.warn("No entry files defined and UI mode is disabled.");
+            process.exit(1);
+        }
+        return (await (0, file_utils_1.globScan)(files, { cwd: root })).files;
+    }
+    else {
+        return await (0, picker_1.pickEntries)(cfg);
+    }
+}

package/dist/core/dependency.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.followChain = followChain;
+exports.applyincludes = applyincludes;
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../constants/config");
+const file_utils_1 = require("./file-utils");
+const logger_1 = require("../lib/logger");
+const utils_1 = require("../lib/utils");
+async function followChain(entryFiles, cfg) {
+    const limit = cfg.resolve.limit;
+    logger_1.logger.debug("🧩 Following dependency chain...");
+    const visited = new Set();
+    const all = [];
+    const expected = new Set();
+    const resolved = new Set();
+    const resolverDepth = cfg.resolve.depth;
+    for (const f of entryFiles) {
+        if (visited.has(f))
+            continue;
+        all.push(f);
+        const ext = path_1.default.extname(f);
+        if (!config_1.CODE_EXTS.includes(ext))
+            continue;
+        const resolver = config_1.RESOLVERS[ext];
+        if (resolver) {
+            const result = await resolver(f, cfg, visited, 0, resolverDepth);
+            const { files, stats } = result;
+            all.push(...files);
+            stats?.expected?.forEach((x) => expected.add(x));
+            stats?.resolved?.forEach((x) => resolved.add(x));
+        }
+        if (limit && all.length >= limit) {
+            logger_1.logger.warn("⚠️  Limit reached:", limit);
+            break;
+        }
+    }
+    return {
+        files: (0, utils_1.unique)(all),
+        stats: { expected, resolved },
+    };
+}
+async function applyincludes(cfg, files) {
+    ;
+    const { resolve } = cfg;
+    const ROOT = cfg.root;
+    const scan = await (0, file_utils_1.globScan)(resolve.include, { cwd: ROOT });
+    logger_1.logger.debug("APPLY_include", _2j(scan));
+    const combined = (0, utils_1.unique)([...files, ...scan.files]);
+    ;
+    return combined;
+}

package/dist/core/file-utils.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globScan = globScan;
+exports.produceSmartName = produceSmartName;
+const path_1 = __importDefault(require("path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const config_1 = require("../constants/config");
+const logger_1 = require("../lib/logger");
+const utils_1 = require("../lib/utils");
+/**
+ * Safe micromatch.scan wrapper (compatible with micromatch v4 & v5)
+ */
+async function globScan(patterns, opts) {
+    logger_1.logger.debug("PATTERNS", patterns);
+    const { absolute = true, cwd = process.cwd() } = opts;
+    if (!patterns?.length)
+        return { files: [] };
+    const files = (await (0, fast_glob_1.default)(patterns, {
+        cwd,
+        extglob: true,
+        dot: true,
+        onlyFiles: true,
+        ignore: config_1.GLOBAL_IGNORE,
+        absolute,
+    })).map((f) => path_1.default.resolve(f));
+    logger_1.logger.debug("GLOB-SCAN_FILES ", _2j(files));
+    return { files };
+}
+function produceSmartName(entries) {
+    const names = (0, utils_1.unique)(entries.map((f) => path_1.default.basename(f, path_1.default.extname(f))));
+    if (names.length === 1)
+        return names[0];
+    if (names.length === 2)
+        return `${names[0]}-${names[1]}`;
+    if (names.length > 2)
+        return `${names[0]}-and-${names.length - 1}more`;
+    return "unknown";
+}

package/dist/core/helpers.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rel = rel;
+exports.read = read;
+exports.isExcluded = isExcluded;
+exports.walk = walk;
+exports.orderByPriority = orderByPriority;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const micromatch_1 = __importDefault(require("micromatch"));
+/**
+ * Get a root-relative version of a path.
+ */
+function rel(p, root = process.cwd()) {
+    return path_1.default.relative(root, p).replaceAll("\\", "/");
+}
+/**
+ * Safe text read.
+ */
+function read(p) {
+    try {
+        return fs_1.default.readFileSync(p, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Check if a path/file matches any of the provided glob patterns.
+ */
+function isExcluded(p, patterns, root = process.cwd()) {
+    if (!patterns?.length)
+        return false;
+    const relPath = rel(p, root);
+    return micromatch_1.default.isMatch(relPath, patterns);
+}
+/**
+ * Recursive walker that respects glob exclude.
+ * Returns all files under the given directory tree.
+ */
+function* walk(dir, cfg, depth = 0) {
+    const { scanDepth, entry } = cfg;
+    const root = process.cwd();
+    if (depth > scanDepth)
+        return;
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const full = path_1.default.join(dir, e.name);
+        if (e.isDirectory()) {
+            // Skip excluded directories entirely
+            const relPath = rel(full, root);
+            if (isExcluded(relPath, entry.exclude))
+                continue;
+            yield* walk(full, cfg, depth + 1);
+            continue;
+        }
+        if (e.isFile()) {
+            const relPath = rel(full, root);
+            if (isExcluded(relPath, entry.exclude))
+                continue;
+            yield full;
+        }
+    }
+}
+function orderByPriority(files, priorityList = []) {
+    if (!priorityList.length)
+        return files;
+    const prioritized = [];
+    const normal = [];
+    for (const f of files) {
+        const normalized = f.norm().toLowerCase();
+        if (priorityList.some(p => micromatch_1.default.isMatch(normalized, p.toLowerCase())))
+            prioritized.push(f);
+        else
+            normal.push(f);
+    }
+    return [...new Set([...prioritized, ...normal])];
+}

package/dist/core/output.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.produceOutput = produceOutput;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const prompt_1 = require("../lib/prompt");
+const renderers_1 = require("./renderers");
+const logger_1 = require("../lib/logger");
+const utils_1 = require("../lib/utils");
+const questions_1 = require("../lib/questions");
+const render_constants_1 = require("../constants/render-constants");
+const config_1 = require("../constants/config");
+/**
+ * 🧩 produceOutput()
+ * Handles rendering and writing of the final trace file.
+ * Receives resolved files and configuration from combine.ts.
+ */
+async function produceOutput({ name, files, cfg, showUi }) {
+    const { output: { format, versioned, dir }, } = cfg;
+    ;
+    // 1️⃣ Determine base filename
+    let outputBase = name;
+    if (showUi) {
+        const result = await (0, prompt_1.prompt)(questions_1.OUTPUT_NAME_QUESTION);
+        if (result?.outputBase)
+            outputBase = result.outputBase;
+    }
+    // 2️⃣ Prefix timestamp if versioned
+    outputBase = `${outputBase}-${config_1.SUFFIX}`;
+    if (versioned)
+        outputBase = `${outputBase}_${(0, utils_1.shortTimestamp)()}`;
+    // 3️⃣ Ensure output directory
+    try {
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    }
+    catch {
+        logger_1.logger.warn("Could not create dir directory:", dir);
+    }
+    // 4️⃣ Prepare and write content
+    const outputPath = path_1.default.join(dir, `${outputBase}.${format}`);
+    const sorted = [...files].sort((a, b) => a.localeCompare(b));
+    const content = format === "txt" ? [(0, renderers_1.tocTxt)(sorted), ...sorted.map(renderers_1.renderTxt)].join("") : [(0, renderers_1.tocMd)(sorted), ...sorted.map((f, i) => (0, renderers_1.renderMd)(f, i)), render_constants_1.MD_FOOTER].join("\n");
+    fs_1.default.writeFileSync(outputPath, content, "utf8");
+    return outputPath;
+}

package/dist/core/parsers/extract-imports.js

@@ -0,0 +1,51 @@
+"use strict";
+// @ts-nocheck
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractImports = extractImports;
+const promises_1 = __importDefault(require("fs/promises"));
+const es_module_lexer_1 = require("es-module-lexer");
+let initialized = false;
+async function extractImports(filePath, code) {
+    if (!initialized) {
+        await es_module_lexer_1.init;
+        initialized = true;
+    }
+    let src = code;
+    if (src == null) {
+        try {
+            src = await promises_1.default.readFile(filePath, "utf8");
+        }
+        catch {
+            return new Set();
+        }
+    }
+    try {
+        const [imports] = (0, es_module_lexer_1.parse)(src);
+        const out = new Set();
+        for (const i of imports)
+            if (i.n)
+                out.add(i.n);
+        return out;
+    }
+    catch {
+        return fallbackRegex(src);
+    }
+}
+function fallbackRegex(code) {
+    const patterns = [
+        /import\s+[^'"]*['"]([^'"]+)['"]/g,
+        /import\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /require\(\s*['"]([^'"]+)['"]\s*\)/g,
+        /export\s+\*\s+from\s+['"]([^'"]+)['"]/g,
+    ];
+    const matches = new Set();
+    for (const r of patterns) {
+        let m;
+        while ((m = r.exec(code)))
+            matches.add(m[1]);
+    }
+    return matches;
+}

package/dist/core/renderers.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tocMd = tocMd;
+exports.renderMd = renderMd;
+exports.tocTxt = tocTxt;
+exports.renderTxt = renderTxt;
+const path_1 = __importDefault(require("path"));
+const helpers_1 = require("./helpers");
+const render_constants_1 = require("../constants/render-constants");
+/**
+ * Generate Markdown Table of Contents with anchors
+ */
+function tocMd(files) {
+    const count = files.length;
+    const items = files.map((f, i) => `- [${(0, helpers_1.rel)(f)}](#${i + 1})`).join("\n");
+    return [`# Index `, `\nIncluded Source Files (${count})`, "", items, "", "---"].join("\n");
+}
+/**
+ * Render each file section with invisible anchors
+ */
+function renderMd(p, i) {
+    const rp = (0, helpers_1.rel)(p);
+    const ext = path_1.default.extname(p).toLowerCase();
+    const lang = render_constants_1.LANG_MAP[ext] || "txt";
+    const code = (0, helpers_1.read)(p).trimEnd();
+    return [`---\n#### ${i + 1}`, "\n", "` File: " + rp + "`  [↑ Back to top](#index)", "", "```" + lang, code, "```", ""].join("\n");
+}
+/**
+ * TXT version (unchanged)
+ */
+function tocTxt(files) {
+    const sorted = [...files].sort((a, b) => a.localeCompare(b));
+    return ["##==== Combined Scope ====", ...sorted.map((f) => "## - " + (0, helpers_1.rel)(f))].join("\n") + "\n\n";
+}
+function renderTxt(p) {
+    const relPath = (0, helpers_1.rel)(p);
+    const code = (0, helpers_1.read)(p);
+    return ["##==== path: " + relPath + " ====", "##region " + relPath, code, "##endregion", ""].join("\n");
+}

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startProdex;
+const combine_1 = require("./core/combine");
+const init_1 = require("./cli/init");
+const cli_input_1 = require("./cli/cli-input");
+const config_loader_1 = require("./constants/config-loader");
+require("./lib/polyfills");
+const summary_1 = require("./cli/summary");
+async function startProdex() {
+    const args = process.argv;
+    // Handle init mode
+    if (args.includes("init")) {
+        return (0, init_1.initProdex)();
+    }
+    // Parse CLI input
+    const { root, flags } = (0, cli_input_1.parseCliInput)(args);
+    // Load and merge configuration (with flag overrides)
+    const config = await (0, config_loader_1.loadProdexConfig)(flags, root);
+    (0, summary_1.introSummary)({ flags, config });
+    const opts = {
+        showUi: !flags.ci && !flags?.files?.length && !config?.entry?.ui?.enablePicker,
+        cliName: config.name,
+    };
+    await (0, combine_1.runCombine)({ cfg: config, opts });
+}

package/dist/lib/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const env = () => {
+    const obj = { debug: process.env.PRODEX_DEBUG === "1", silent: process.env.PRODEX_SILENT === "1" };
+    return obj;
+};
+exports.logger = {
+    debug: (...args) => !env().silent && env().debug && console.log("\n🪶 [debug]", ...args),
+    info: (...args) => !env().silent && console.log("\n📌 [info]", ...args),
+    warn: (...args) => !env().silent && console.warn("\n⚠️  [warn]", ...args),
+    error: (...args) => !env().silent && console.error("\n💥 [error]", ...args),
+    log: (...args) => !env().silent && console.log("\n", ...args),
+};

package/dist/lib/polyfills.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = __importDefault(require("util"));
+if (!String.prototype.norm) {
+    String.prototype.norm = function () {
+        return this.replace(/\\/g, "/");
+    };
+}
+if (!String.prototype.clean) {
+    String.prototype.clean = function () {
+        return this.replace(/[<>:\"/\\|?*]+/g, "_");
+    };
+}
+globalThis._2j = (obj) => util_1.default.inspect(obj, { colors: true, depth: null, breakLength: 150, compact: 3 });
+globalThis._bpt = function (param) {
+    if (process.env.PRODEX_DEBUG !== "1")
+        return;
+    console.log("⭕ BREAKPOINT");
+    if (typeof param === "function")
+        param();
+    else
+        console.log(_2j(param));
+    process.exit(1);
+};