storm-lua-minify 0.3.0 → 0.9.0

package/dist/callGraph.js

@@ -0,0 +1,372 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combineCallGraphs = combineCallGraphs;
+exports.analyzeCallGraph = analyzeCallGraph;
+/** Combine generation-matched module graphs and replace proved method unknown edges. */
+function combineCallGraphs(graphs, resolvedTargets, generation) {
+    if (graphs.some((graph) => graph.generation !== generation))
+        throw new Error("Cannot combine call graphs from different AST generations");
+    const functions = [...new Set(graphs.flatMap((graph) => graph.functions))];
+    const calls = [];
+    const callSiteByExpression = new WeakMap();
+    graphs
+        .flatMap((graph) => graph.calls)
+        .forEach((original) => {
+        const resolved = resolvedTargets.get(original);
+        const targets = resolved
+            ? new Set([...original.targets, resolved])
+            : original.targets;
+        const call = {
+            ...original,
+            id: calls.length,
+            targets,
+            hasUnknownTarget: resolved ? false : original.hasUnknownTarget,
+        };
+        calls.push(call);
+        callSiteByExpression.set(call.call, call);
+    });
+    const sccs = stronglyConnectedComponents(functions, calls);
+    return {
+        generation,
+        functions,
+        calls,
+        sccs,
+        functionOf: (declaration) => {
+            for (const graph of graphs) {
+                const found = graph.functionOf(declaration);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        },
+        functionOfSymbol: (symbol) => {
+            for (const graph of graphs) {
+                const found = graph.functionOfSymbol(symbol);
+                if (found)
+                    return found;
+            }
+            return undefined;
+        },
+        callSiteOf: (call) => callSiteByExpression.get(call),
+    };
+}
+/**
+ * Resolve identityに基づくmodule-local call graphを構築する。
+ *
+ * 名前文字列やsource rangeからcall targetを推測しない。現行のoptimizer snapshotは
+ * module単位なので、global/module/external edgeはknown targetと偽らずunknown bitとして
+ * 保持する。local aliasは単一代入の関数値だけを有限固定点で解決する。
+ */
+function analyzeCallGraph(chunk, resolved, facts) {
+    const functions = [];
+    const functionByDeclaration = new WeakMap();
+    const functionBySymbol = new Map();
+    const ownerFunction = new WeakMap();
+    const directFunctionBySymbol = new Map();
+    const aliasSources = new Map();
+    const assignmentOriginBySymbol = new Map();
+    const conflictingBindings = new Set();
+    const registerFunction = (declaration, symbol) => {
+        const existing = functionByDeclaration.get(declaration);
+        if (existing)
+            return existing;
+        const scope = resolved.scopeOfFunction(declaration);
+        const callable = {
+            id: functions.length,
+            declaration,
+            ...(symbol ? { symbol } : {}),
+            parameters: scope?.symbols.filter((candidate) => candidate.kind === "param") ?? [],
+        };
+        functions.push(callable);
+        functionByDeclaration.set(declaration, callable);
+        if (symbol)
+            directFunctionBySymbol.set(symbol, callable);
+        return callable;
+    };
+    const visitExpression = (expression, current) => {
+        switch (expression.type) {
+            case "FunctionDeclaration": {
+                const callable = registerFunction(expression);
+                visitBlock(expression.body, callable);
+                return;
+            }
+            case "CallExpression":
+                visitExpression(expression.base, current);
+                expression.arguments.forEach((argument) => {
+                    visitExpression(argument, current);
+                });
+                return;
+            case "TableCallExpression":
+                visitExpression(expression.base, current);
+                visitExpression(expression.arguments, current);
+                return;
+            case "StringCallExpression":
+                visitExpression(expression.base, current);
+                visitExpression(expression.argument, current);
+                return;
+            case "BinaryExpression":
+            case "LogicalExpression":
+                visitExpression(expression.left, current);
+                visitExpression(expression.right, current);
+                return;
+            case "UnaryExpression":
+                visitExpression(expression.argument, current);
+                return;
+            case "MemberExpression":
+                visitExpression(expression.base, current);
+                return;
+            case "IndexExpression":
+                visitExpression(expression.base, current);
+                visitExpression(expression.index, current);
+                return;
+            case "TableConstructorExpression":
+                expression.fields.forEach((field) => {
+                    if (field.type === "TableKey")
+                        visitExpression(field.key, current);
+                    visitExpression(field.value, current);
+                });
+                return;
+            case "Identifier":
+            case "NilLiteral":
+            case "BooleanLiteral":
+            case "NumericLiteral":
+            case "StringLiteral":
+            case "VarargLiteral":
+                return;
+        }
+    };
+    const rememberBinding = (target, expression, assignment = false) => {
+        const symbol = resolved.symbolOf(target);
+        if (!symbol || !expression)
+            return;
+        if (directFunctionBySymbol.has(symbol) ||
+            aliasSources.has(symbol) ||
+            assignmentOriginBySymbol.has(symbol))
+            conflictingBindings.add(symbol);
+        if (assignment)
+            assignmentOriginBySymbol.set(symbol, target);
+        if (expression.type === "FunctionDeclaration") {
+            directFunctionBySymbol.set(symbol, registerFunction(expression, symbol));
+            return;
+        }
+        if (expression.type !== "Identifier")
+            return;
+        const source = resolved.symbolOf(expression);
+        if (source)
+            aliasSources.set(symbol, source);
+    };
+    function visitStatement(statement, current) {
+        if (current)
+            ownerFunction.set(statement, current);
+        switch (statement.type) {
+            case "LocalStatement":
+                statement.variables.forEach((target, index) => {
+                    rememberBinding(target, statement.init[index]);
+                });
+                statement.init.forEach((expression) => {
+                    visitExpression(expression, current);
+                });
+                return;
+            case "AssignmentStatement":
+                statement.variables.forEach((target, index) => {
+                    if (target.type === "Identifier")
+                        rememberBinding(target, statement.init[index], true);
+                });
+                statement.init.forEach((expression) => {
+                    visitExpression(expression, current);
+                });
+                return;
+            case "FunctionDeclaration": {
+                const symbol = statement.identifier?.type === "Identifier"
+                    ? resolved.symbolOf(statement.identifier)
+                    : undefined;
+                const callable = registerFunction(statement, symbol);
+                visitBlock(statement.body, callable);
+                return;
+            }
+            case "CallStatement":
+                visitExpression(statement.expression, current);
+                return;
+            case "ReturnStatement":
+                statement.arguments.forEach((expression) => {
+                    visitExpression(expression, current);
+                });
+                return;
+            case "DoStatement":
+                visitBlock(statement.body, current);
+                return;
+            case "WhileStatement":
+                visitExpression(statement.condition, current);
+                visitBlock(statement.body, current);
+                return;
+            case "RepeatStatement":
+                visitBlock(statement.body, current);
+                visitExpression(statement.condition, current);
+                return;
+            case "IfStatement":
+                statement.clauses.forEach((clause) => {
+                    if (clause.type !== "ElseClause")
+                        visitExpression(clause.condition, current);
+                    visitBlock(clause.body, current);
+                });
+                return;
+            case "ForNumericStatement":
+                visitExpression(statement.start, current);
+                visitExpression(statement.end, current);
+                if (statement.step)
+                    visitExpression(statement.step, current);
+                visitBlock(statement.body, current);
+                return;
+            case "ForGenericStatement":
+                statement.iterators.forEach((expression) => {
+                    visitExpression(expression, current);
+                });
+                visitBlock(statement.body, current);
+                return;
+            case "BreakStatement":
+            case "LabelStatement":
+            case "GotoStatement":
+                return;
+        }
+    }
+    function visitBlock(body, current) {
+        body.forEach((statement) => {
+            visitStatement(statement, current);
+        });
+    }
+    visitBlock(chunk.body);
+    const isStableBinding = (symbol) => {
+        if (conflictingBindings.has(symbol))
+            return false;
+        const writes = facts
+            .operationsOfSymbol(symbol)
+            .filter((operation) => operation.kind === "write");
+        const assignmentOrigin = assignmentOriginBySymbol.get(symbol);
+        return assignmentOrigin
+            ? writes.length === 1 && writes[0].origin === assignmentOrigin
+            : writes.length === 0;
+    };
+    directFunctionBySymbol.forEach((callable, symbol) => {
+        if (isStableBinding(symbol))
+            functionBySymbol.set(symbol, callable);
+    });
+    let changed = true;
+    while (changed) {
+        changed = false;
+        aliasSources.forEach((source, target) => {
+            if (functionBySymbol.has(target))
+                return;
+            if (!isStableBinding(target) || !isStableBinding(source))
+                return;
+            const callable = functionBySymbol.get(source);
+            if (!callable)
+                return;
+            functionBySymbol.set(target, callable);
+            changed = true;
+        });
+    }
+    const calls = [];
+    const callSiteByExpression = new WeakMap();
+    facts.operations.forEach((operation) => {
+        if (operation.kind !== "call")
+            return;
+        const targets = new Set();
+        if (operation.target.kind === "local" ||
+            operation.target.kind === "parameter" ||
+            operation.target.kind === "upvalue") {
+            const target = functionBySymbol.get(operation.target.symbol);
+            if (target)
+                targets.add(target);
+        }
+        const site = {
+            id: calls.length,
+            call: operation.call,
+            owner: operation.owner,
+            caller: ownerFunction.get(operation.owner),
+            targets,
+            hasUnknownTarget: targets.size === 0,
+            ...(operation.call.base.type === "Identifier" &&
+                (operation.target.kind === "global" ||
+                    operation.target.kind === "external")
+                ? { externalTargetName: operation.call.base.name }
+                : {}),
+        };
+        calls.push(site);
+        callSiteByExpression.set(operation.call, site);
+    });
+    const sccs = stronglyConnectedComponents(functions, calls);
+    return {
+        generation: facts.generation,
+        functions,
+        calls,
+        sccs,
+        functionOf: (declaration) => functionByDeclaration.get(declaration),
+        functionOfSymbol: (symbol) => functionBySymbol.get(symbol),
+        callSiteOf: (call) => callSiteByExpression.get(call),
+    };
+}
+function stronglyConnectedComponents(functions, calls) {
+    const edges = new Map(functions.map((callable) => [callable, new Set()]));
+    calls.forEach((call) => {
+        if (!call.caller)
+            return;
+        const outgoing = edges.get(call.caller);
+        call.targets.forEach((target) => outgoing?.add(target));
+    });
+    let nextIndex = 0;
+    const index = new Map();
+    const lowlink = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const components = [];
+    const connect = (callable) => {
+        index.set(callable, nextIndex);
+        lowlink.set(callable, nextIndex++);
+        stack.push(callable);
+        onStack.add(callable);
+        edges.get(callable)?.forEach((target) => {
+            if (!index.has(target)) {
+                connect(target);
+                const callableLowlink = lowlink.get(callable);
+                const targetLowlink = lowlink.get(target);
+                if (callableLowlink === undefined || targetLowlink === undefined)
+                    throw new Error("Tarjan lowlink is missing");
+                lowlink.set(callable, Math.min(callableLowlink, targetLowlink));
+            }
+            else if (onStack.has(target)) {
+                const callableLowlink = lowlink.get(callable);
+                const targetIndex = index.get(target);
+                if (callableLowlink === undefined || targetIndex === undefined)
+                    throw new Error("Tarjan index is missing");
+                lowlink.set(callable, Math.min(callableLowlink, targetIndex));
+            }
+        });
+        if (lowlink.get(callable) !== index.get(callable))
+            return;
+        const component = [];
+        while (stack.length > 0) {
+            const member = stack.pop();
+            if (!member)
+                throw new Error("Tarjan stack underflow");
+            onStack.delete(member);
+            component.push(member);
+            if (member === callable)
+                break;
+        }
+        components.push(component.sort((left, right) => left.id - right.id));
+    };
+    functions.forEach((callable) => {
+        if (!index.has(callable))
+            connect(callable);
+    });
+    return components
+        .sort((left, right) => left[0].id - right[0].id)
+        .map((component, id) => ({
+        id,
+        functions: component,
+        recursive: component.length > 1 ||
+            (component.length === 1 &&
+                edges.get(component[0])?.has(component[0])) ||
+            false,
+    }));
+}

package/dist/cli.js

@@ -6,21 +6,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const commander_1 = require("commander");
 const minifier_1 = require("./minifier");
 const output_1 = require("./output");
-const program = new commander_1.Command();
-program
-    .version("0.3.0")
-    .description("A Lua minifier also outputs source map")
-    .option("-m, --module-like-lua", "require・dofileの動作を実際のLuaに近づけます")
-    .option("--no-rename", "識別子の短縮(リネーム)を無効にします（デバッグ用途）")
-    .option("--no-global-rename", "内部でのみ使用するグローバル識別子の短縮を無効にします（デバッグ用途）")
-    .option("--no-merge-locals", "連続するローカル変数宣言のまとめ上げを無効にします（デバッグ用途）")
-    .option("--no-global-alias", "外部グローバル識別子（リネームできないもの）のローカル代入短縮を無効にします（デバッグ用途）")
-    .option("--reserved-globals-config <path>", '代入されていても短縮しないグローバル名を列挙したJSON設定ファイルのパス（{"neverRenameGlobals":["onTick",...]}形式）。エンジン側のコールバック規約名など、常に元の名前のまま残す必要がある識別子を指定します')
-    .option("--single-line-source-mapping-url", "sourceMappingURLアノテーションを単一行の--コメントで出力します（Source Map仕様の「最終行」ルールに従いますが、既定の複数行ブロックコメント形式を前提とするツールとは組み合わせられません）")
-    .option("--strict-source-mapping-url", "sourceMappingURLアノテーションをLuaコメントで一切包まず、Source Map仕様のマーカー文字列(//# sourceMappingURL=...)そのままを出力します。Luaの文法上この形式と有効なLuaコードは両立できないため、出力ファイルの最終行は有効なLua文ではなくなります");
+const cliOptions_1 = require("./cliOptions");
+const config_1 = require("./config");
+const options_1 = require("./options");
+const cliProgress_1 = require("./cliProgress");
+const program = (0, cliOptions_1.createCliProgram)();
 program.parse(process.argv);
 const luaFiles = program.args;
 const luaparseSetting = {
@@ -29,53 +21,56 @@ const luaparseSetting = {
     ranges: true,
     scope: true,
 };
-function isReservedGlobalsConfig(value) {
-    if (typeof value !== "object" || value === null) {
-        return false;
-    }
-    const candidate = value;
-    return (Array.isArray(candidate.neverRenameGlobals) &&
-        candidate.neverRenameGlobals.every((name) => typeof name === "string"));
-}
-function loadNeverRenameGlobals(configPath) {
-    if (!fs_1.default.existsSync(configPath)) {
-        throw new Error("Reserved globals config not found: " + configPath);
-    }
-    const parsed = JSON.parse(fs_1.default.readFileSync(configPath).toString());
-    if (!isReservedGlobalsConfig(parsed)) {
-        throw new Error(configPath +
-            ' must be a JSON object of the form {"neverRenameGlobals": ["name", ...]}');
-    }
-    return new Set(parsed.neverRenameGlobals);
-}
-const { singleLineSourceMappingUrl, strictSourceMappingUrl, reservedGlobalsConfig, ...mode } = program.opts();
-if (reservedGlobalsConfig) {
-    mode.neverRenameGlobals = loadNeverRenameGlobals(reservedGlobalsConfig);
-}
-// 既定は旧バージョンと互換の複数行ブロックコメント("legacy")。
-// --strict-source-mapping-url > --single-line-source-mapping-url の優先順で上書きする。
-const sourceMappingUrlStyle = strictSourceMappingUrl
-    ? "strict"
-    : singleLineSourceMappingUrl
-        ? "line"
-        : "legacy";
-luaFiles.forEach((fileName) => {
+const { config: configPath, neverRenameGlobal, progress: progressOption, requiredWhitespace, sourceMappingUrlStyle: cliSourceMappingUrlStyle, ...cliModeOptions } = program.opts();
+const cliMode = cliModeOptions;
+if (neverRenameGlobal !== undefined)
+    cliMode.neverRenameGlobals = new Set(neverRenameGlobal);
+if (requiredWhitespace !== undefined)
+    cliMode.requiredWhitespace = requiredWhitespace === "space" ? " " : "\n";
+const configuration = configPath
+    ? (0, config_1.loadConfiguration)(configPath)
+    : { mode: {} };
+const mode = (0, options_1.resolveMinifierMode)({
+    config: configuration.mode,
+    cli: cliMode,
+    defaults: { requireWrapper: false, runtimeProfile: "stormworks" },
+});
+const sourceMappingUrlStyle = cliSourceMappingUrlStyle ?? configuration.sourceMappingUrlStyle ?? "legacy";
+luaFiles.forEach((fileName, fileIndex) => {
     const parsedFileName = path_1.default.parse(fileName);
     if (fs_1.default.existsSync(fileName)) {
-        const map = new minifier_1.Minifier(fileName, luaparseSetting, mode).parse();
-        const minFileName = path_1.default.format({
-            dir: parsedFileName.dir,
-            name: parsedFileName.name + ".min",
-            ext: ".lua",
-        });
-        const mapFileName = path_1.default.format({
-            dir: parsedFileName.dir,
-            name: parsedFileName.name,
-            ext: parsedFileName.ext + ".map",
-        });
-        const { code, map: mapJson } = (0, output_1.buildMinifiedOutput)(map, minFileName, mapFileName, { sourceMappingUrlStyle });
-        fs_1.default.writeFileSync(minFileName, code);
-        fs_1.default.writeFileSync(mapFileName, mapJson);
+        const progress = (0, cliProgress_1.progressEnabled)(progressOption, process.stderr)
+            ? new cliProgress_1.CliProgress({
+                fileName,
+                fileIndex: fileIndex + 1,
+                fileCount: luaFiles.length,
+                output: process.stderr,
+            })
+            : undefined;
+        const startedAt = performance.now();
+        try {
+            const map = new minifier_1.Minifier(fileName, luaparseSetting, mode, progress).parse();
+            const minFileName = path_1.default.format({
+                dir: parsedFileName.dir,
+                name: parsedFileName.name + ".min",
+                ext: ".lua",
+            });
+            const mapFileName = path_1.default.format({
+                dir: parsedFileName.dir,
+                name: parsedFileName.name,
+                ext: parsedFileName.ext + ".map",
+            });
+            progress?.addSteps(1);
+            progress?.startStep("Write Lua and source map files");
+            const { code, map: mapJson } = (0, output_1.buildMinifiedOutput)(map, minFileName, mapFileName, { sourceMappingUrlStyle });
+            fs_1.default.writeFileSync(minFileName, code);
+            fs_1.default.writeFileSync(mapFileName, mapJson);
+            progress?.finish([minFileName, mapFileName], performance.now() - startedAt);
+        }
+        catch (error) {
+            progress?.fail();
+            throw error;
+        }
     }
     else {
         console.error("No such file: " + fileName);

package/dist/cliOptions.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliProgram = createCliProgram;
+const commander_1 = require("commander");
+const options_1 = require("./options");
+function addBooleanSwitch(command, name, description, shortName) {
+    command.addOption(new commander_1.Option(shortName ? `${shortName}, --${name}` : `--${name}`, description).default(undefined));
+    command.addOption(new commander_1.Option(`--no-${name}`, `Disable ${description.toLowerCase()}`).default(undefined));
+}
+/** Build the v1 CLI surface without materializing inherited defaults. */
+function createCliProgram() {
+    const command = new commander_1.Command()
+        .version("0.9.0")
+        .description("A Lua minifier also outputs source map")
+        .option("--config <path>", "JSON configuration file")
+        .addOption(new commander_1.Option("--runtime-profile <profile>", "Target runtime semantics")
+        .choices(["stormworks", "lua53"])
+        .default(undefined))
+        .addOption(new commander_1.Option("--required-whitespace <style>", "Required token separator style")
+        .choices(["space", "lf"])
+        .default(undefined))
+        .addOption(new commander_1.Option("--never-rename-global <name>", "Global name that must remain externally visible (repeatable)").argParser((name, names) => [...(names ?? []), name]))
+        .addOption(new commander_1.Option("--source-mapping-url-style <style>", "sourceMappingURL output style")
+        .choices(["legacy", "line", "strict"])
+        .default(undefined));
+    addBooleanSwitch(command, "progress", "Show compilation progress");
+    addBooleanSwitch(command, "require-wrapper", "Expand require through a generated function wrapper", "-m");
+    options_1.optimizationOptionDefinitions.forEach((definition) => {
+        addBooleanSwitch(command, definition.name, `Enable ${definition.name}`);
+    });
+    addBooleanSwitch(command, "allow-introspection-changes", "Allow changes observable through debug introspection");
+    addBooleanSwitch(command, "allow-observable-table-read-changes", "Allow table reads to cross writes that may change their values");
+    addBooleanSwitch(command, "assume-annotations", "Trust supported EmmyLua annotations as optimizer facts");
+    addBooleanSwitch(command, "collect-optimization-diagnostics", "Collect optimizer decision diagnostics");
+    return command;
+}

package/dist/cliProgress.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliProgress = exports.CLI_PROGRESS_INTERVAL_MS = void 0;
+exports.progressEnabled = progressEnabled;
+const path_1 = __importDefault(require("path"));
+const SPINNER_FRAMES = ["|", "/", "-", "\\"];
+/** Minimum elapsed time between spinner frames; change and rebuild to tune it. */
+exports.CLI_PROGRESS_INTERVAL_MS = 200;
+class CliProgress {
+    displayName;
+    filePosition;
+    output;
+    now;
+    tty;
+    currentStep = 0;
+    totalSteps = 0;
+    label = "Starting";
+    spinnerIndex = 0;
+    lastRenderAt;
+    activeLine = false;
+    constructor(options) {
+        this.displayName = path_1.default.basename(options.fileName);
+        this.filePosition =
+            String(options.fileIndex) + "/" + String(options.fileCount) + " files";
+        this.output = options.output;
+        this.now = options.now ?? (() => performance.now());
+        this.tty = options.output.isTTY === true;
+    }
+    addSteps(count) {
+        if (!Number.isInteger(count) || count < 0)
+            throw new Error("Progress step count must be a non-negative integer");
+        this.totalSteps += count;
+    }
+    startStep(label) {
+        this.currentStep++;
+        this.label = label;
+        if (this.currentStep > this.totalSteps)
+            this.totalSteps = this.currentStep;
+        if (this.tty)
+            this.render(this.now());
+        else
+            this.output.write(this.line() + "\n");
+    }
+    tick() {
+        if (!this.tty || this.lastRenderAt === undefined)
+            return;
+        const now = this.now();
+        if (now - this.lastRenderAt < exports.CLI_PROGRESS_INTERVAL_MS)
+            return;
+        this.spinnerIndex = (this.spinnerIndex + 1) % SPINNER_FRAMES.length;
+        this.render(now);
+    }
+    finish(outputFiles, elapsedMs) {
+        const destinations = outputFiles.join(", ");
+        const line = `[done] [${this.filePosition}] ${this.displayName} (${formatDuration(elapsedMs)}) -> ${destinations}`;
+        this.writeFinalLine(line);
+    }
+    fail() {
+        this.writeFinalLine(`[failed] [${this.filePosition}] ${this.displayName} — ${this.label}`);
+    }
+    line() {
+        return `${SPINNER_FRAMES[this.spinnerIndex]} [${this.filePosition}] ${this.displayName} — Step ${String(this.currentStep)}/${String(this.totalSteps)}: ${this.label}`;
+    }
+    render(now) {
+        this.output.write(`\r\x1b[2K${this.line()}`);
+        this.lastRenderAt = now;
+        this.activeLine = true;
+    }
+    writeFinalLine(line) {
+        if (this.tty && this.activeLine)
+            this.output.write("\r\x1b[2K");
+        this.output.write(line + "\n");
+        this.activeLine = false;
+    }
+}
+exports.CliProgress = CliProgress;
+function formatDuration(elapsedMs) {
+    if (elapsedMs < 1000)
+        return `${String(Math.round(elapsedMs))} ms`;
+    return `${(elapsedMs / 1000).toFixed(1)} s`;
+}
+function progressEnabled(explicit, output) {
+    return explicit ?? output.isTTY === true;
+}