@udondan/avanti 0.24.0 → 0.26.0

package/dist/sources/index.js

@@ -37,6 +37,8 @@ exports._testable = void 0;
 exports.resolveJsonOptions = resolveJsonOptions;
 exports.resolveYamlOptions = resolveYamlOptions;
 exports.resolveTomlOptions = resolveTomlOptions;
+exports.resolveIniOptions = resolveIniOptions;
+exports.formatSourceLabel = formatSourceLabel;
 exports.fetchSource = fetchSource;
 const crypto = __importStar(require("crypto"));
 const os = __importStar(require("os"));
@@ -60,10 +62,15 @@ const vault_1 = require("./vault");
 const json_1 = require("../processors/json");
 const yaml_1 = require("../processors/yaml");
 const toml_1 = require("../processors/toml");
+const ini_1 = require("../processors/ini");
 const binary_1 = require("../binary");
+const filter_1 = require("../filter");
+const extract_1 = require("../extract");
+const config_1 = require("../config");
 const JSON_EXTENSIONS = new Set(['.json', '.jsonc']);
 const YAML_EXTENSIONS = new Set(['.yaml', '.yml']);
 const TOML_EXTENSIONS = new Set(['.toml']);
+const INI_EXTENSIONS = new Set(['.ini', '.cfg']);
 function srcFilename(src) {
     if (typeof src === 'string') {
         if (src.startsWith('http://') || src.startsWith('https://')) {
@@ -144,6 +151,12 @@ function hasTomlExtension(src) {
         return false;
     return TOML_EXTENSIONS.has(path.extname(name).toLowerCase());
 }
+function hasIniExtension(src) {
+    const name = srcFilename(src);
+    if (!name)
+        return false;
+    return INI_EXTENSIONS.has(path.extname(name).toLowerCase());
+}
 function resolveJsonOptions(entry, srcs) {
     const { json } = entry;
     if (json === false)
@@ -183,12 +196,40 @@ function resolveTomlOptions(entry, srcs) {
         return {};
     return null;
 }
+function resolveIniOptions(entry, srcs) {
+    const { ini } = entry;
+    if (ini === false)
+        return null;
+    if (ini === true)
+        return {};
+    if (ini !== undefined && typeof ini === 'object')
+        return ini;
+    // Auto-detect: all sources have an INI file extension
+    if (srcs.length > 0 && srcs.every(hasIniExtension))
+        return {};
+    return null;
+}
 // labelForSrc returns the source label used in SourceFetchRecord. Structured
 // sources (github:, gitlab:, etc.) keep variable references unresolved so the
 // label matches the literal YAML values that applyUpdatedShas reads for SHA
 // writeback. Plain-string sources resolve variables since they don't support
-// SHA pinning.
+// SHA pinning. When a filter is present a NUL-byte separator (\x00) is used
+// before "filter:<json>" so the label is unambiguous even if the base contains
+// the display string " | filter:" (e.g. a local path with that literal text).
+// Use formatSourceLabel() to convert to a human-readable form for display.
 function labelForSrc(src, vars) {
+    const base = baseLabelForSrc(src, vars);
+    const filter = filterForSrc(src);
+    if (filter && filter.length > 0)
+        return `${base}\x00filter:${JSON.stringify(filter)}`;
+    return base;
+}
+// formatSourceLabel converts an internal label (which may contain a NUL-byte
+// filter separator) into a human-readable string for log/error output.
+function formatSourceLabel(label) {
+    return label.replace('\x00filter:', ' | filter:');
+}
+function baseLabelForSrc(src, vars) {
     if (typeof src === 'string')
         return (0, variables_1.resolveVars)(src, vars);
     if ('github' in src) {
@@ -253,6 +294,7 @@ function labelForSrc(src, vars) {
 // using variables are correctly distinguished when vars change between
 // stabilization iterations, and raw: sources are keyed by their content.
 function cacheKeyForSrc(src, vars) {
+    let base;
     if (typeof src === 'string')
         return (0, variables_1.resolveVars)(src, vars);
     if ('github' in src) {
@@ -265,12 +307,14 @@ function cacheKeyForSrc(src, vars) {
             : (src.github.via ?? 'api,cli');
         const via = viaStr === 'api,cli' ? '' : `(${viaStr})`;
         if ('release' in src.github) {
-            return `github${host}:${(0, variables_1.resolveVars)(src.github.repo, vars)}:release:${(0, variables_1.resolveVars)(src.github.release, vars)}${via}`;
+            base = `github${host}:${(0, variables_1.resolveVars)(src.github.repo, vars)}:release:${(0, variables_1.resolveVars)(src.github.release, vars)}${via}`;
+        }
+        else {
+            const ref = src.github.ref ? `@${(0, variables_1.resolveVars)(src.github.ref, vars)}` : '';
+            base = `github${host}:${(0, variables_1.resolveVars)(src.github.repo, vars)}:${(0, variables_1.resolveVars)(src.github.file, vars)}${ref}${via}`;
         }
-        const ref = src.github.ref ? `@${(0, variables_1.resolveVars)(src.github.ref, vars)}` : '';
-        return `github${host}:${(0, variables_1.resolveVars)(src.github.repo, vars)}:${(0, variables_1.resolveVars)(src.github.file, vars)}${ref}${via}`;
     }
-    if ('gitlab' in src) {
+    else if ('gitlab' in src) {
         const resolvedHost = src.gitlab.host
             ? (0, variables_1.resolveVars)(src.gitlab.host, vars).trim()
             : '';
@@ -280,12 +324,14 @@ function cacheKeyForSrc(src, vars) {
             : (src.gitlab.via ?? 'api,cli');
         const via = viaStr === 'api,cli' ? '' : `(${viaStr})`;
         if ('release' in src.gitlab) {
-            return `gitlab${host}:${(0, variables_1.resolveVars)(src.gitlab.project, vars)}:release:${(0, variables_1.resolveVars)(src.gitlab.release, vars)}${via}`;
+            base = `gitlab${host}:${(0, variables_1.resolveVars)(src.gitlab.project, vars)}:release:${(0, variables_1.resolveVars)(src.gitlab.release, vars)}${via}`;
+        }
+        else {
+            const ref = src.gitlab.ref ? `@${(0, variables_1.resolveVars)(src.gitlab.ref, vars)}` : '';
+            base = `gitlab${host}:${(0, variables_1.resolveVars)(src.gitlab.project, vars)}:${(0, variables_1.resolveVars)(src.gitlab.file, vars)}${ref}${via}`;
         }
-        const ref = src.gitlab.ref ? `@${(0, variables_1.resolveVars)(src.gitlab.ref, vars)}` : '';
-        return `gitlab${host}:${(0, variables_1.resolveVars)(src.gitlab.project, vars)}:${(0, variables_1.resolveVars)(src.gitlab.file, vars)}${ref}${via}`;
     }
-    if ('bitbucket' in src) {
+    else if ('bitbucket' in src) {
         const ref = src.bitbucket.ref
             ? `@${(0, variables_1.resolveVars)(src.bitbucket.ref, vars)}`
             : '';
@@ -293,17 +339,19 @@ function cacheKeyForSrc(src, vars) {
             ? (0, variables_1.resolveVars)(src.bitbucket.host, vars).trim()
             : '';
         const host = resolvedHost ? `[${resolvedHost}]` : '';
-        return `bitbucket${host}:${(0, variables_1.resolveVars)(src.bitbucket.workspace, vars)}/${(0, variables_1.resolveVars)(src.bitbucket.repo, vars)}:${(0, variables_1.resolveVars)(src.bitbucket.file, vars)}${ref}`;
+        base = `bitbucket${host}:${(0, variables_1.resolveVars)(src.bitbucket.workspace, vars)}/${(0, variables_1.resolveVars)(src.bitbucket.repo, vars)}:${(0, variables_1.resolveVars)(src.bitbucket.file, vars)}${ref}`;
     }
-    if ('git' in src) {
+    else if ('git' in src) {
         const ref = src.git.ref ? `@${(0, variables_1.resolveVars)(src.git.ref, vars)}` : '';
-        return `git:${(0, variables_1.resolveVars)(src.git.repo, vars)}:${(0, variables_1.resolveVars)(src.git.file, vars)}${ref}`;
+        base = `git:${(0, variables_1.resolveVars)(src.git.repo, vars)}:${(0, variables_1.resolveVars)(src.git.file, vars)}${ref}`;
     }
-    if ('exec' in src)
+    else if ('exec' in src) {
         return `exec:${(0, variables_1.resolveVars)(src.exec, vars)}`;
-    if ('aws_s3' in src)
-        return `aws_s3:${(0, variables_1.resolveVars)(src.aws_s3, vars)}`;
-    if ('aws_secrets_manager' in src) {
+    }
+    else if ('aws_s3' in src) {
+        base = `aws_s3:${(0, variables_1.resolveVars)(src.aws_s3, vars)}`;
+    }
+    else if ('aws_secrets_manager' in src) {
         const k = src.aws_secrets_manager.key !== undefined
             ? `#${(0, variables_1.resolveVars)(src.aws_secrets_manager.key, vars)}`
             : '';
@@ -312,28 +360,35 @@ function cacheKeyForSrc(src, vars) {
             : '';
         return `aws_secrets_manager:${(0, variables_1.resolveVars)(src.aws_secrets_manager.name, vars)}${k}${r}`;
     }
-    if ('aws_systems_manager_parameter' in src) {
+    else if ('aws_systems_manager_parameter' in src) {
         const r = src.aws_systems_manager_parameter.region !== undefined
             ? `@${(0, variables_1.resolveVars)(src.aws_systems_manager_parameter.region, vars)}`
             : '';
         return `aws_systems_manager_parameter:${(0, variables_1.resolveVars)(src.aws_systems_manager_parameter.name, vars)}${r}`;
     }
-    if ('vault' in src) {
+    else if ('vault' in src) {
         const field = src.vault.field
             ? `#${(0, variables_1.resolveVars)(src.vault.field, vars)}`
             : '';
         return `vault:${(0, variables_1.resolveVars)(src.vault.path, vars)}${field}`;
     }
-    if ('http' in src)
+    else if ('http' in src) {
         return `http:${(0, variables_1.resolveVars)(src.http, vars)}`;
-    if ('path' in src)
-        return `path:${(0, variables_1.resolveVars)(src.path, vars)}`;
-    if ('url' in src)
+    }
+    else if ('path' in src) {
+        base = `path:${(0, variables_1.resolveVars)(src.path, vars)}`;
+    }
+    else if ('url' in src) {
         return `url:${(0, variables_1.resolveVars)(src.url, vars)}`;
-    // raw: key includes the resolved content so distinct raw values don't collide
-    if ('raw' in src)
+    }
+    else if ('raw' in src) {
+        // raw: key includes the resolved content so distinct raw values don't collide
         return `raw:${(0, variables_1.resolveVars)(src.raw, vars)}`;
-    return JSON.stringify(src);
+    }
+    else {
+        return JSON.stringify(src);
+    }
+    return base;
 }
 function expectedShaForSrc(src) {
     if (typeof src === 'string')
@@ -383,6 +438,23 @@ function buildRecord(src, files, vars) {
         matched: expectedSha === undefined || expectedSha === observedSha,
     };
 }
+function filterForSrc(src) {
+    if (typeof src === 'string')
+        return undefined;
+    if ('github' in src)
+        return src.filter;
+    if ('gitlab' in src)
+        return src.filter;
+    if ('bitbucket' in src)
+        return src.filter;
+    if ('git' in src)
+        return src.filter;
+    if ('aws_s3' in src)
+        return src.filter;
+    if ('path' in src)
+        return src.filter;
+    return undefined;
+}
 function computeFilesSha(files) {
     // Always include filename in the hash so a rename/path change affects the SHA
     // consistently, whether the source resolves to one file or many.
@@ -396,21 +468,46 @@ function computeFilesSha(files) {
     }
     return hash.digest('hex');
 }
-async function _fetchOneSrcRaw(src, workingDir, vars) {
+async function _fetchOneSrcRaw(src, workingDir, vars, configBase) {
     if ((0, logger_1.isVerbose)())
-        (0, logger_1.verbose)(`fetching source: ${(0, fetch_1.redactUrl)(labelForSrc(src, vars))}`);
+        (0, logger_1.verbose)(`fetching source: ${(0, fetch_1.redactUrl)(formatSourceLabel(labelForSrc(src, vars)))}`);
     if (typeof src === 'string') {
         const resolved = (0, variables_1.resolveVars)(src, vars);
-        if (resolved.startsWith('http://') || resolved.startsWith('https://')) {
-            const content = await (0, http_1.fetchHttp)(resolved);
-            const filename = (0, http_1.inferFilenameFromUrl)(resolved) ?? 'download';
+        const effective = configBase !== undefined
+            ? (0, config_1.resolveRelativeSrc)(resolved, configBase)
+            : resolved;
+        if (effective.startsWith('http://') || effective.startsWith('https://')) {
+            const content = await (0, http_1.fetchHttp)(effective);
+            const filename = (0, http_1.inferFilenameFromUrl)(effective) ?? 'download';
             return { files: new Map([[filename, content]]) };
         }
-        if ((0, git_1.isGitRemoteUrl)(resolved)) {
-            const { repo, file, ref } = (0, git_1.parseGitRemoteSpec)(resolved);
+        if ((0, git_1.isGitRemoteUrl)(effective)) {
+            const { repo, file, ref } = (0, git_1.parseGitRemoteSpec)(effective);
             return { files: (0, git_1.fetchGit)(repo, file, ref).files };
         }
-        return { files: (0, local_1.fetchLocal)(resolved, workingDir).files };
+        if (effective.startsWith('github:')) {
+            let parsedGh;
+            try {
+                parsedGh = (0, config_1.parseGitHubSpec)(effective);
+            }
+            catch {
+                throw new Error(`Invalid github source spec "${effective}". Expected: github:owner/repo:path/to/file[@ref]`);
+            }
+            const result = await (0, github_1.fetchGitHub)(parsedGh.repo, parsedGh.file, parsedGh.ref);
+            return { files: result.files };
+        }
+        if (effective.startsWith('gitlab:')) {
+            let parsedGl;
+            try {
+                parsedGl = (0, config_1.parseGitLabSpec)(effective);
+            }
+            catch {
+                throw new Error(`Invalid gitlab source spec "${effective}". Expected: gitlab:group/project:path/to/file[@ref]`);
+            }
+            const result = await (0, gitlab_1.fetchGitLab)(parsedGl.project, parsedGl.file, parsedGl.ref);
+            return { files: result.files };
+        }
+        return { files: (0, local_1.fetchLocal)(effective, workingDir).files };
     }
     if ('raw' in src) {
         return {
@@ -531,7 +628,7 @@ async function _fetchOneSrcRaw(src, workingDir, vars) {
     }
     return { files };
 }
-async function fetchOneSrc(src, workingDir, vars, cache, getTargetPath = () => '', pendingWrites) {
+async function fetchOneSrc(src, workingDir, vars, cache, getTargetPath = () => '', pendingWrites, configBase) {
     // Evaluate source-level conditions before the cache so a cached result for
     // the same URL is not returned when conditions gate this source out.
     if (typeof src !== 'string') {
@@ -547,7 +644,7 @@ async function fetchOneSrc(src, workingDir, vars, cache, getTargetPath = () => '
     // write target in this run should resolve to the future content, not whatever
     // is on disk (or in the cache from a previous iteration).
     if (pendingWrites !== undefined) {
-        const pending = pendingLocalFiles(src, workingDir, vars, pendingWrites);
+        const pending = pendingLocalFiles(src, workingDir, vars, pendingWrites, configBase);
         if (pending !== null) {
             return { files: pending, record: buildRecord(src, pending, vars) };
         }
@@ -558,11 +655,11 @@ async function fetchOneSrc(src, workingDir, vars, cache, getTargetPath = () => '
     let skipped;
     if (cached !== undefined) {
         if ((0, logger_1.isVerbose)())
-            (0, logger_1.verbose)(`cache hit: ${(0, fetch_1.redactUrl)(labelForSrc(src, vars))}`);
+            (0, logger_1.verbose)(`cache hit: ${(0, fetch_1.redactUrl)(formatSourceLabel(labelForSrc(src, vars)))}`);
         files = cached.files;
     }
     else {
-        const raw = await _fetchOneSrcRaw(src, workingDir, vars);
+        const raw = await _fetchOneSrcRaw(src, workingDir, vars, configBase);
         files = raw.files;
         skipped = raw.skipped;
         // Don't cache skipped results: if optional changes to required between
@@ -572,11 +669,16 @@ async function fetchOneSrc(src, workingDir, vars, cache, getTargetPath = () => '
     }
     if (skipped)
         return { files: new Map(), record: null, skipped: true };
+    const rawFilter = filterForSrc(src);
+    const filterPatterns = rawFilter?.map((p) => (0, variables_1.resolveVars)(p, vars));
+    if (filterPatterns && filterPatterns.length > 0) {
+        files = (0, filter_1.applyFilter)(files, filterPatterns);
+    }
     // Recompute record from the current source spec so expectedSha/matched
     // always reflect the caller's config iteration, not the first fetch.
     return { files, record: buildRecord(src, files, vars) };
 }
-function pendingLocalFiles(src, workingDir, vars, pendingWrites) {
+function pendingLocalFiles(src, workingDir, vars, pendingWrites, configBase) {
     let rawPath = null;
     try {
         if (typeof src === 'string') {
@@ -584,7 +686,16 @@ function pendingLocalFiles(src, workingDir, vars, pendingWrites) {
             if (!resolved.startsWith('http://') &&
                 !resolved.startsWith('https://') &&
                 !(0, git_1.isGitRemoteUrl)(resolved)) {
-                rawPath = resolved;
+                const effective = configBase !== undefined
+                    ? (0, config_1.resolveRelativeSrc)(resolved, configBase)
+                    : resolved;
+                if (!effective.startsWith('http://') &&
+                    !effective.startsWith('https://') &&
+                    !(0, git_1.isGitRemoteUrl)(effective) &&
+                    !effective.startsWith('github:') &&
+                    !effective.startsWith('gitlab:')) {
+                    rawPath = effective;
+                }
             }
         }
         else if ('path' in src) {
@@ -634,7 +745,7 @@ function assertTextFiles(files, context) {
         }
     }
 }
-async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOverride, pendingWrites) {
+async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOverride, pendingWrites, configBase) {
     const { src } = entry;
     const getTargetPath = getTargetPathOverride ??
         (() => (0, paths_1.resolveTargetPath)(entry, '', workingDir, vars));
@@ -644,7 +755,7 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         const sourceRecords = [];
         for (let i = 0; i < src.length; i++) {
             try {
-                const { files, record, skipped } = await fetchOneSrc(src[i], workingDir, vars, cache, getTargetPath, pendingWrites);
+                const { files, record, skipped } = await fetchOneSrc(src[i], workingDir, vars, cache, getTargetPath, pendingWrites, configBase);
                 if (skipped)
                     continue;
                 assertTextFiles(files, `source ${i}`);
@@ -667,6 +778,9 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         const tomlOpts = jsonOpts === null && yamlOpts === null
             ? resolveTomlOptions(entry, src)
             : null;
+        const iniOpts = jsonOpts === null && yamlOpts === null && tomlOpts === null
+            ? resolveIniOptions(entry, src)
+            : null;
         let content;
         if (jsonOpts !== null) {
             content = (0, json_1.mergeJson)(parts, jsonOpts);
@@ -677,6 +791,9 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         else if (tomlOpts !== null) {
             content = (0, toml_1.mergeToml)(parts, tomlOpts);
         }
+        else if (iniOpts !== null) {
+            content = (0, ini_1.mergeIni)(parts, iniOpts);
+        }
         else {
             content = parts.join('\n');
         }
@@ -686,10 +803,37 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         };
     }
     // Single src — delegate dispatch to fetchOneSrc, then apply post-processing
-    const { files: singleFiles, record: singleRecord, skipped, } = await fetchOneSrc(src, workingDir, vars, cache, getTargetPath, pendingWrites);
+    const { files: singleFiles, record: singleRecord, skipped, } = await fetchOneSrc(src, workingDir, vars, cache, getTargetPath, pendingWrites, configBase);
     if (skipped)
         return { files: new Map(), sourceRecords: [], allSkipped: true };
-    const singleResult = { files: singleFiles };
+    let resolvedFiles = singleFiles;
+    if (entry.extract !== undefined) {
+        if (singleFiles.size !== 1) {
+            throw new Error(`"extract" requires a single-file source, but source returned ${singleFiles.size} file(s)`);
+        }
+        const [[archiveFilename, archiveBuffer]] = [...singleFiles.entries()];
+        if ((0, extract_1.detectArchiveFormat)(archiveFilename) === null) {
+            throw new Error(`"extract" was specified but "${archiveFilename}" is not a recognised archive format`);
+        }
+        const extracted = await (0, extract_1.extractArchive)(archiveBuffer, archiveFilename);
+        if (entry.extract === true) {
+            resolvedFiles = extracted;
+        }
+        else {
+            const resolvedPatterns = entry.extract.map((p) => (0, variables_1.resolveVars)(p, vars));
+            try {
+                resolvedFiles = (0, filter_1.applyFilter)(extracted, resolvedPatterns);
+            }
+            catch (err) {
+                if (err instanceof Error &&
+                    err.message.startsWith('filter matched no files')) {
+                    throw new Error(`extract matched no entries (${resolvedPatterns.length} pattern${resolvedPatterns.length === 1 ? '' : 's'}: ${resolvedPatterns.map((p) => JSON.stringify(p)).join(', ')})`, { cause: err });
+                }
+                throw err;
+            }
+        }
+    }
+    const singleResult = { files: resolvedFiles };
     const sourceRecords = singleRecord !== null ? [singleRecord] : [];
     // When a directory source resolves to multiple files but the target is a
     // single file (no trailing slash), merge all files sorted by name instead
@@ -704,7 +848,13 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         let dirTomlOpts = dirJsonOpts === null && dirYamlOpts === null
             ? resolveTomlOptions(entry, [src])
             : null;
-        if (dirJsonOpts === null && dirYamlOpts === null && dirTomlOpts === null) {
+        let dirIniOpts = dirJsonOpts === null && dirYamlOpts === null && dirTomlOpts === null
+            ? resolveIniOptions(entry, [src])
+            : null;
+        if (dirJsonOpts === null &&
+            dirYamlOpts === null &&
+            dirTomlOpts === null &&
+            dirIniOpts === null) {
             const keys = Array.from(singleResult.files.keys());
             if (entry.json !== false &&
                 keys.every((k) => JSON_EXTENSIONS.has(path.extname(k).toLowerCase()))) {
@@ -718,8 +868,15 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
                 keys.every((k) => TOML_EXTENSIONS.has(path.extname(k).toLowerCase()))) {
                 dirTomlOpts = {};
             }
+            else if (entry.ini !== false &&
+                keys.every((k) => INI_EXTENSIONS.has(path.extname(k).toLowerCase()))) {
+                dirIniOpts = {};
+            }
         }
-        if (dirJsonOpts !== null || dirYamlOpts !== null || dirTomlOpts !== null) {
+        if (dirJsonOpts !== null ||
+            dirYamlOpts !== null ||
+            dirTomlOpts !== null ||
+            dirIniOpts !== null) {
             assertTextFiles(singleResult.files, 'directory merge');
             const sortedValues = Array.from(singleResult.files.entries())
                 .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
@@ -732,9 +889,12 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
             else if (dirYamlOpts !== null) {
                 merged = (0, yaml_1.mergeYaml)(sortedValues, dirYamlOpts);
             }
-            else {
+            else if (dirTomlOpts !== null) {
                 merged = (0, toml_1.mergeToml)(sortedValues, dirTomlOpts);
             }
+            else {
+                merged = (0, ini_1.mergeIni)(sortedValues, dirIniOpts);
+            }
             return {
                 files: new Map([[filename, Buffer.from(merged, 'utf8')]]),
                 sourceRecords,
@@ -747,9 +907,15 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
     const singleTomlOpts = singleJsonOpts === null && singleYamlOpts === null
         ? resolveTomlOptions(entry, [src])
         : null;
+    const singleIniOpts = singleJsonOpts === null &&
+        singleYamlOpts === null &&
+        singleTomlOpts === null
+        ? resolveIniOptions(entry, [src])
+        : null;
     if (singleJsonOpts === null &&
         singleYamlOpts === null &&
-        singleTomlOpts === null)
+        singleTomlOpts === null &&
+        singleIniOpts === null)
         return { ...singleResult, sourceRecords };
     const formatted = new Map();
     for (const [k, v] of singleResult.files) {
@@ -758,7 +924,9 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
                 ? 'json'
                 : singleYamlOpts !== null
                     ? 'yaml'
-                    : 'toml';
+                    : singleTomlOpts !== null
+                        ? 'toml'
+                        : 'ini';
             throw new Error(`Binary file "${k}" cannot be formatted as ${fmtName}. Remove the format option or use a text source.`);
         }
         const text = v.toString('utf8');
@@ -768,9 +936,12 @@ async function fetchSource(entry, workingDir, vars = {}, cache, getTargetPathOve
         else if (singleYamlOpts !== null) {
             formatted.set(k, Buffer.from((0, yaml_1.formatYaml)(text), 'utf8'));
         }
-        else {
+        else if (singleTomlOpts !== null) {
             formatted.set(k, Buffer.from((0, toml_1.formatToml)(text), 'utf8'));
         }
+        else {
+            formatted.set(k, Buffer.from((0, ini_1.formatIni)(text), 'utf8'));
+        }
     }
     return { files: formatted, sourceRecords };
 }