@zokugun/artifact 0.5.1 → 0.6.0

package/lib/utils/command/merge-flag-tokens.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFlagTokens = mergeFlagTokens;
 function mergeFlagTokens(currentFlags, incomingFlags) {
-    const mergedFlags = currentFlags.slice();
+    const mergedFlags = [...currentFlags];
     for (const flag of incomingFlags) {
         const name = flag.split(/\s+/)[0];
         const exists = mergedFlags.some((existing) => existing.split(/\s+/)[0] === name);

package/lib/utils/command/merge-flags-as-string.d.ts

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

package/lib/utils/command/merge-flags-as-string.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFlagsAsString = mergeFlagsAsString;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergeFlagsAsString(current, incoming) {
-    const currentPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(current);
-    const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(currentPrefix.flags, incoming.flags);
+    const currentPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(current);
+    const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentPrefix.flags, incoming.flags);
     return currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
 }

package/lib/utils/command/merge-or-segments.d.ts

@@ -0,0 +1 @@
+export declare function mergeOrSegments(current: string, incoming: string): string;

package/lib/utils/command/merge-or-segments.js

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeOrSegments = mergeOrSegments;
-const dedupe_strings_1 = require("./dedupe-strings");
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const merge_semicolon_segments_1 = require("./merge-semicolon-segments");
-const prefix_of_command_1 = require("./prefix-of-command");
-const split_chain_1 = require("./split-chain");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
-const split_segments_1 = require("./split-segments");
+const dedupe_strings_js_1 = require("./dedupe-strings.js");
+const merge_flags_as_string_js_1 = require("./merge-flags-as-string.js");
+const merge_semicolon_segments_js_1 = require("./merge-semicolon-segments.js");
+const prefix_of_command_js_1 = require("./prefix-of-command.js");
+const split_chain_js_1 = require("./split-chain.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
+const split_segments_js_1 = require("./split-segments.js");
 function mergeOrSegments(current, incoming) {
-    const currentSegments = (0, split_segments_1.splitSegments)(current);
-    const incomingSegments = (0, split_segments_1.splitSegments)(incoming);
-    const currentOrIdx = currentSegments.findIndex((s) => s.includes('||'));
-    const incomingOrIdx = incomingSegments.findIndex((s) => s.includes('||'));
-    if (currentOrIdx === -1 || incomingOrIdx === -1) {
-        return (0, merge_semicolon_segments_1.mergeSemicolonSegments)(current, incoming);
+    const currentSegments = (0, split_segments_js_1.splitSegments)(current);
+    const incomingSegments = (0, split_segments_js_1.splitSegments)(incoming);
+    const currentOrIndex = currentSegments.findIndex((s) => s.includes('||'));
+    const incomingOrIndex = incomingSegments.findIndex((s) => s.includes('||'));
+    if (currentOrIndex === -1 || incomingOrIndex === -1) {
+        return (0, merge_semicolon_segments_js_1.mergeSemicolonSegments)(current, incoming);
     }
-    const currentParts = (0, split_chain_1.splitChain)(currentSegments[currentOrIdx], '||');
-    const incomingParts = (0, split_chain_1.splitChain)(incomingSegments[incomingOrIdx], '||');
-    const currentTail = currentSegments.filter((_, idx) => idx !== currentOrIdx);
-    const incomingTail = incomingSegments.filter((_, idx) => idx !== incomingOrIdx);
+    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[currentOrIndex], '||');
+    const incomingParts = (0, split_chain_js_1.splitChain)(incomingSegments[incomingOrIndex], '||');
+    const currentTail = currentSegments.filter((_, index) => index !== currentOrIndex);
+    const incomingTail = incomingSegments.filter((_, index) => index !== incomingOrIndex);
     const maxLength = Math.max(currentParts.length, incomingParts.length);
     const chainResult = [];
     const movedToTail = [];
@@ -27,14 +27,14 @@ function mergeOrSegments(current, incoming) {
         const currentPart = currentParts[i];
         const incomingPart = incomingParts[i];
         if (currentPart && incomingPart) {
-            const cPref = (0, prefix_of_command_1.prefixOfCommand)(currentPart);
-            const nPref = (0, prefix_of_command_1.prefixOfCommand)(incomingPart);
+            const cPref = (0, prefix_of_command_js_1.prefixOfCommand)(currentPart);
+            const nPref = (0, prefix_of_command_js_1.prefixOfCommand)(incomingPart);
             if (cPref && nPref && cPref === nPref) {
                 if (incomingTail.length > 0) {
-                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(incomingPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(currentPart)));
+                    chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(incomingPart, (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentPart)));
                 }
                 else {
-                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart)));
+                    chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingPart)));
                 }
             }
             else if (incomingTail.some((t) => t === currentPart || t.startsWith(`${currentPart} `))) {
@@ -64,22 +64,22 @@ function mergeOrSegments(current, incoming) {
     }
     const chainParts = new Set(dedupedChain);
     const rawTail = [...currentTail, ...movedToTail, ...incomingTail];
-    const filteredTail = rawTail.filter((tail, idx) => {
+    const filteredTail = rawTail.filter((tail, index) => {
         if (chainParts.has(tail)) {
             return false;
         }
         // Keep only the most specific tail when two tails share a prefix.
-        return !rawTail.some((other, otherIdx) => otherIdx !== idx && other.startsWith(`${tail} `));
+        return !rawTail.some((other, otherIndex) => otherIndex !== index && other.startsWith(`${tail} `));
     });
     const mergedChain = dedupedChain.join(' || ');
-    const chainPrefixes = new Set(dedupedChain.map(prefix_of_command_1.prefixOfCommand).filter(Boolean));
+    const chainPrefixes = new Set(dedupedChain.map(prefix_of_command_js_1.prefixOfCommand).filter(Boolean));
     const mergedSegs = currentSegments
-        .map((seg, idx) => (idx === currentOrIdx ? mergedChain : seg))
-        .filter((seg, idx) => idx === currentOrIdx || !chainPrefixes.has((0, prefix_of_command_1.prefixOfCommand)(seg)));
-    for (const tail of (0, dedupe_strings_1.dedupeStrings)(filteredTail)) {
+        .map((seg, index) => (index === currentOrIndex ? mergedChain : seg))
+        .filter((seg, index) => index === currentOrIndex || !chainPrefixes.has((0, prefix_of_command_js_1.prefixOfCommand)(seg)));
+    for (const tail of (0, dedupe_strings_js_1.dedupeStrings)(filteredTail)) {
         if (!mergedSegs.includes(tail)) {
             mergedSegs.push(tail);
         }
     }
-    return (0, dedupe_strings_1.dedupeStrings)(mergedSegs).join('; ');
+    return (0, dedupe_strings_js_1.dedupeStrings)(mergedSegs).join('; ');
 }

package/lib/utils/command/merge-parts-by-prefix.d.ts

@@ -0,0 +1 @@
+export declare function mergePartsByPrefix(currentParts: string[], incomingParts: string[]): string[];

package/lib/utils/command/merge-parts-by-prefix.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergePartsByPrefix = mergePartsByPrefix;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergePartsByPrefix(currentParts, incomingParts) {
-    const result = currentParts.slice();
+    const result = [...currentParts];
     for (const incomingPart of incomingParts) {
-        const incomingPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart);
+        const incomingPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingPart);
         let merged = false;
         for (let k = 0; k < result.length; k++) {
-            const currentPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(result[k]);
+            const currentPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(result[k]);
             if (currentPrefix.prefix && incomingPrefix.prefix && currentPrefix.prefix === incomingPrefix.prefix) {
-                const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
+                const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
                 result[k] = currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
                 merged = true;
                 break;

package/lib/utils/command/merge-semicolon-segments.d.ts

@@ -0,0 +1 @@
+export declare function mergeSemicolonSegments(current: string, incoming: string): string;

package/lib/utils/command/merge-semicolon-segments.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeSemicolonSegments = mergeSemicolonSegments;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const merge_parts_by_prefix_1 = require("./merge-parts-by-prefix");
-const prefix_of_command_1 = require("./prefix-of-command");
-const split_chain_1 = require("./split-chain");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
-const split_segments_1 = require("./split-segments");
+const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
+const merge_flags_as_string_js_1 = require("./merge-flags-as-string.js");
+const merge_parts_by_prefix_js_1 = require("./merge-parts-by-prefix.js");
+const prefix_of_command_js_1 = require("./prefix-of-command.js");
+const split_chain_js_1 = require("./split-chain.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
+const split_segments_js_1 = require("./split-segments.js");
 function mergeSemicolonSegments(current, incoming) {
-    let currentSegments = (0, split_segments_1.splitSegments)(current);
-    const incomingSegments = (0, split_segments_1.splitSegments)(incoming);
+    let currentSegments = (0, split_segments_js_1.splitSegments)(current);
+    const incomingSegments = (0, split_segments_js_1.splitSegments)(incoming);
     for (const incomingSegment of incomingSegments) {
         // If the incoming segment is itself a chain (&& or ||), merge subparts accordingly
         if (incomingSegment.includes('||')) {
@@ -18,12 +18,12 @@ function mergeSemicolonSegments(current, incoming) {
             let mergedIntoCurrent = false;
             for (let j = 0; j < currentSegments.length; j++) {
                 if (currentSegments[j].includes('||')) {
-                    const currentParts = (0, split_chain_1.splitChain)(currentSegments[j], '||');
-                    const newParts = (0, merge_parts_by_prefix_1.mergePartsByPrefix)(currentParts, incomingParts);
+                    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[j], '||');
+                    const newParts = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentParts, incomingParts);
                     currentSegments[j] = newParts.join(' || ');
                     // remove duplicates that were absorbed
-                    currentSegments = currentSegments.filter((s, idx) => {
-                        if (idx === j) {
+                    currentSegments = currentSegments.filter((s, index) => {
+                        if (index === j) {
                             return true;
                         }
                         for (const np of newParts) {
@@ -43,48 +43,48 @@ function mergeSemicolonSegments(current, incoming) {
             continue;
         }
         if (incomingSegment.includes('&&')) {
-            const incomingParts = (0, split_chain_1.splitChain)(incomingSegment, '&&');
+            const incomingParts = (0, split_chain_js_1.splitChain)(incomingSegment, '&&');
             let mergedIntoCurrent = false;
             for (let j = 0; j < currentSegments.length; j++) {
                 if (currentSegments[j].includes('&&')) {
-                    const currentParts = (0, split_chain_1.splitChain)(currentSegments[j], '&&');
+                    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[j], '&&');
                     // If first prefixes align, do positional merge preferring incoming flags first
                     let newParts = [];
-                    if (currentParts.length > 0 && incomingParts.length > 0 && (0, prefix_of_command_1.prefixOfCommand)(currentParts[0]) === (0, prefix_of_command_1.prefixOfCommand)(incomingParts[0])) {
+                    if (currentParts.length > 0 && incomingParts.length > 0 && (0, prefix_of_command_js_1.prefixOfCommand)(currentParts[0]) === (0, prefix_of_command_js_1.prefixOfCommand)(incomingParts[0])) {
                         const maxLength = Math.max(currentParts.length, incomingParts.length);
                         for (let i = 0; i < maxLength; i++) {
-                            const curPart = currentParts[i];
+                            const currentPart = currentParts[i];
                             const incPart = incomingParts[i];
-                            if (curPart && incPart) {
-                                const curP = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(curPart);
-                                const incP = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incPart);
-                                if (curP.prefix && incP.prefix && curP.prefix === incP.prefix) {
+                            if (currentPart && incPart) {
+                                const currentP = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentPart);
+                                const incP = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incPart);
+                                if (currentP.prefix && incP.prefix && currentP.prefix === incP.prefix) {
                                     // keep current flags first, then append incoming flags if missing
-                                    const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(curP.flags, incP.flags);
-                                    newParts.push(curP.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : ''));
+                                    const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentP.flags, incP.flags);
+                                    newParts.push(currentP.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : ''));
                                     continue;
                                 }
                             }
-                            if (curPart) {
-                                newParts.push(curPart);
+                            if (currentPart) {
+                                newParts.push(currentPart);
                             }
-                            if (!curPart && incPart) {
+                            if (!currentPart && incPart) {
                                 newParts.push(incPart);
                             }
                         }
                         currentSegments[j] = newParts.join(' && ');
                     }
                     else {
-                        newParts = (0, merge_parts_by_prefix_1.mergePartsByPrefix)(currentParts, incomingParts);
+                        newParts = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentParts, incomingParts);
                         currentSegments[j] = newParts.join(' && ');
                     }
                     // remove duplicates that were absorbed — compare by prefix to avoid formatting mismatches
-                    const newPrefixes = new Set(newParts.map(prefix_of_command_1.prefixOfCommand).filter(Boolean));
-                    currentSegments = currentSegments.filter((s, idx) => {
-                        if (idx === j) {
+                    const newPrefixes = new Set(newParts.map(prefix_of_command_js_1.prefixOfCommand).filter(Boolean));
+                    currentSegments = currentSegments.filter((s, index) => {
+                        if (index === j) {
                             return true;
                         }
-                        const sp = (0, prefix_of_command_1.prefixOfCommand)(s);
+                        const sp = (0, prefix_of_command_js_1.prefixOfCommand)(s);
                         if (sp && newPrefixes.has(sp)) {
                             return false;
                         }
@@ -99,12 +99,12 @@ function mergeSemicolonSegments(current, incoming) {
             }
             continue;
         }
-        const incomingPartsObject = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingSegment);
+        const incomingPartsObject = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment);
         let matched = false;
         for (let i = 0; i < currentSegments.length; i++) {
-            const currentPartsObject = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(currentSegments[i]);
+            const currentPartsObject = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentSegments[i]);
             if (currentPartsObject.prefix && incomingPartsObject.prefix && currentPartsObject.prefix === incomingPartsObject.prefix) {
-                currentSegments[i] = (0, merge_flags_as_string_1.mergeFlagsAsString)(currentSegments[i], incomingPartsObject);
+                currentSegments[i] = (0, merge_flags_as_string_js_1.mergeFlagsAsString)(currentSegments[i], incomingPartsObject);
                 matched = true;
                 break;
             }
@@ -117,7 +117,7 @@ function mergeSemicolonSegments(current, incoming) {
     const seen = [];
     const deduped = [];
     for (const s of currentSegments) {
-        const p = (0, prefix_of_command_1.prefixOfCommand)(s) || s;
+        const p = (0, prefix_of_command_js_1.prefixOfCommand)(s) || s;
         if (!seen.includes(p)) {
             seen.push(p);
             deduped.push(s);

package/lib/utils/command/merge-with-semicolon-mix.d.ts

@@ -0,0 +1 @@
+export declare function mergeWithSemicolonMix(current: string, incoming: string): string | undefined;

package/lib/utils/command/merge-with-semicolon-mix.js

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeWithSemicolonMix = mergeWithSemicolonMix;
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const split_chain_1 = require("./split-chain");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flags_as_string_js_1 = require("./merge-flags-as-string.js");
+const split_chain_js_1 = require("./split-chain.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergeWithSemicolonMix(current, incoming) {
     if (!(incoming.includes('&&') && current.includes(';'))) {
         return;
     }
     const allSegments = current.split(/;|&&/).map((s) => s.trim()).filter(Boolean);
     const chainPart = current.split(';')[0] || '';
-    const chainCount = chainPart ? (0, split_chain_1.splitChain)(chainPart, '&&').length : 0;
+    const chainCount = chainPart ? (0, split_chain_js_1.splitChain)(chainPart, '&&').length : 0;
     const currentChain = allSegments.slice(0, chainCount);
     const tail = allSegments.slice(chainCount);
-    const incomingAnd = (0, split_chain_1.splitChain)(incoming, '&&');
-    const chainResult = currentChain.slice();
+    const incomingAnd = (0, split_chain_js_1.splitChain)(incoming, '&&');
+    const chainResult = [...currentChain];
     const appendedTailIdxs = [];
     for (const incomingSegment of incomingAnd) {
-        const incomingParts = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingSegment);
+        const incomingParts = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment);
         let matched = false;
         for (const [i, allSegment] of allSegments.entries()) {
-            const currentParts = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(allSegment);
+            const currentParts = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(allSegment);
             if (currentParts.prefix && incomingParts.prefix && currentParts.prefix === incomingParts.prefix) {
                 if (i < chainCount) {
                     // merge into existing chain position
-                    const idx = i;
-                    chainResult[idx] = (0, merge_flags_as_string_1.mergeFlagsAsString)(chainResult[idx], incomingParts);
+                    const index = i;
+                    chainResult[index] = (0, merge_flags_as_string_js_1.mergeFlagsAsString)(chainResult[index], incomingParts);
                 }
                 else {
                     // append matching tail segment into chain if not already appended
                     if (!appendedTailIdxs.includes(i)) {
-                        chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(allSegment, incomingParts));
+                        chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(allSegment, incomingParts));
                         appendedTailIdxs.push(i);
                     }
                 }
@@ -43,6 +43,6 @@ function mergeWithSemicolonMix(current, incoming) {
         }
     }
     // Build remaining tail excluding appended indices
-    const remainingTail = tail.filter((_, idx) => !appendedTailIdxs.includes(chainCount + idx));
+    const remainingTail = tail.filter((_, index) => !appendedTailIdxs.includes(chainCount + index));
     return chainResult.join(' && ') + (remainingTail.length > 0 ? '; ' + remainingTail.join('; ') : '');
 }

package/lib/utils/command/prefix-of-command.d.ts

@@ -0,0 +1 @@
+export declare function prefixOfCommand(command: string): string;

package/lib/utils/command/prefix-of-command.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prefixOfCommand = prefixOfCommand;
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function prefixOfCommand(command) {
-    return (0, split_prefix_and_flags_1.splitPrefixAndFlags)(command).prefix;
+    return (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(command).prefix;
 }

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

@@ -0,0 +1 @@
+export declare function splitChain(s: string, operator: '&&' | '||'): string[];

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

@@ -0,0 +1,2 @@
+import { type Command } from '../../types/command.js';
+export declare function splitCommand(command: string): Record<string, Command[]>;

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,5 @@
+import { IndentStyle } from '../types/format.js';
+export declare function detectIndent(text: string): {
+    style: IndentStyle;
+    size: number;
+};

package/lib/utils/detect-indent.js

@@ -0,0 +1,60 @@
+"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,
+        };
+    }
+    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;