@jbrowse/cli 3.6.0 → 3.6.1

package/dist/commands/track-utils.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTrackConfigPath = resolveTrackConfigPath;
+exports.loadTrackConfig = loadTrackConfig;
+exports.processTrackFiles = processTrackFiles;
+exports.addTrackToConfig = addTrackToConfig;
+exports.saveTrackConfigAndReport = saveTrackConfigAndReport;
+exports.buildTrackParams = buildTrackParams;
+exports.createTrackConfiguration = createTrackConfiguration;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("../utils");
+const adapter_utils_1 = require("./add-track-utils/adapter-utils");
+const file_operations_1 = require("./add-track-utils/file-operations");
+const track_config_1 = require("./add-track-utils/track-config");
+const validators_1 = require("./add-track-utils/validators");
+function resolveTrackConfigPath(output) {
+    const isDir = fs_1.default.lstatSync(output).isDirectory();
+    return isDir ? `${output}/config.json` : output;
+}
+async function loadTrackConfig(targetConfigPath) {
+    return await (0, utils_1.readJsonFile)(targetConfigPath);
+}
+async function processTrackFiles({ location, index, bed1, bed2, load, configDir, subDir, force, }) {
+    if (load) {
+        await Promise.all(Object.values((0, adapter_utils_1.guessFileNames)({ location, index, bed1, bed2 }))
+            .filter(f => !!f)
+            .map(src => (0, file_operations_1.loadFile)({
+            src,
+            destDir: configDir,
+            mode: load,
+            subDir,
+            force,
+        })));
+    }
+}
+function addTrackToConfig({ configContents, trackConfig, trackId, force, overwrite, }) {
+    const idx = (0, validators_1.validateTrackId)(configContents, trackId, force, overwrite);
+    const updatedConfig = { ...configContents };
+    if (idx !== -1) {
+        (0, utils_1.debug)(`Found existing trackId ${trackId} in configuration`);
+        (0, utils_1.debug)(`Overwriting track ${trackId} in configuration`);
+        updatedConfig.tracks[idx] = trackConfig;
+        return { updatedConfig, wasOverwritten: true };
+    }
+    else {
+        updatedConfig.tracks.push(trackConfig);
+        return { updatedConfig, wasOverwritten: false };
+    }
+}
+async function saveTrackConfigAndReport({ config, targetConfigPath, name, trackId, wasOverwritten, }) {
+    (0, utils_1.debug)(`Writing configuration to file ${targetConfigPath}`);
+    await (0, utils_1.writeJsonFile)(targetConfigPath, config);
+    console.log(`${wasOverwritten ? 'Overwrote' : 'Added'} track with name "${name}" and trackId "${trackId}" ${wasOverwritten ? 'in' : 'to'} ${targetConfigPath}`);
+}
+function buildTrackParams({ flags, location, adapter, configContents, }) {
+    const trackType = flags.trackType || (0, adapter_utils_1.guessTrackType)(adapter.type);
+    const trackId = flags.trackId || path_1.default.basename(location, path_1.default.extname(location));
+    const name = flags.name || trackId;
+    const assemblyNames = flags.assemblyNames || configContents.assemblies?.[0]?.name || '';
+    return {
+        trackType,
+        trackId,
+        name,
+        assemblyNames,
+    };
+}
+function createTrackConfiguration({ location, trackParams, flags, adapter, configContents, skipCheck, }) {
+    return (0, track_config_1.buildTrackConfig)({
+        location,
+        trackType: trackParams.trackType,
+        trackId: trackParams.trackId,
+        name: trackParams.name,
+        assemblyNames: trackParams.assemblyNames,
+        category: flags.category,
+        description: flags.description,
+        config: flags.config,
+        adapter,
+        configContents,
+        skipCheck,
+    });
+}

package/dist/commands/upgrade.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+const decompress_1 = __importDefault(require("decompress"));
+const fetchWithProxy_1 = __importDefault(require("../fetchWithProxy"));
+const utils_1 = require("../utils");
+const description = 'Upgrades JBrowse 2 to latest version';
+const examples = [
+    '# Upgrades current directory to latest jbrowse release',
+    '$ jbrowse upgrade',
+    '',
+    '# Upgrade jbrowse instance at a specific filesystem path',
+    '$ jbrowse upgrade /path/to/jbrowse2/installation',
+    '',
+    '# Upgrade to a specific tag',
+    '$ jbrowse upgrade /path/to/jbrowse2/installation --tag v1.0.0',
+    '',
+    '# List versions available on github',
+    '$ jbrowse upgrade --listVersions',
+    '',
+    '# Upgrade from a specific URL',
+    '$ jbrowse upgrade --url https://sample.com/jbrowse2.zip',
+    '',
+    '# Get nightly release from main branch',
+    '$ jbrowse upgrade --nightly',
+];
+const options = {
+    help: {
+        type: 'boolean',
+        short: 'h',
+        description: 'Display help for command',
+    },
+    // will need to account for pagination once there is a lot of releases
+    listVersions: {
+        type: 'boolean',
+        short: 'l',
+        description: 'Lists out all versions of JBrowse 2',
+    },
+    tag: {
+        type: 'string',
+        short: 't',
+        description: 'Version of JBrowse 2 to install. Format is v1.0.0.\nDefaults to latest',
+    },
+    branch: {
+        type: 'string',
+        description: 'Download a development build from a named git branch',
+    },
+    nightly: {
+        type: 'boolean',
+        description: 'Download the latest development build from the main branch',
+    },
+    clean: {
+        type: 'boolean',
+        description: 'Removes old js,map,and LICENSE files in the installation',
+    },
+    url: {
+        type: 'string',
+        short: 'u',
+        description: 'A direct URL to a JBrowse 2 release',
+    },
+};
+async function run(args) {
+    const { positionals, values: runFlags } = (0, util_1.parseArgs)({
+        options,
+        args,
+        allowPositionals: true,
+    });
+    const argsPath = positionals[0];
+    const { clean, listVersions, tag, url, branch, nightly } = runFlags;
+    if (runFlags.help) {
+        (0, utils_1.printHelp)({
+            options,
+            examples,
+            usage: 'jbrowse upgrade [localPath] [options]',
+            description,
+        });
+        return;
+    }
+    if (listVersions) {
+        const versions = (await (0, utils_1.fetchGithubVersions)()).map(v => v.tag_name);
+        console.log(`All JBrowse versions:\n${versions.join('\n')}`);
+        process.exit(0);
+    }
+    if (!argsPath) {
+        throw new Error('No directory supplied');
+    }
+    if (!fs_1.default.existsSync(path_1.default.join(argsPath, 'manifest.json'))) {
+        throw new Error(`No manifest.json found in this directory, are you sure it is an
+        existing jbrowse 2 installation?`);
+    }
+    const locationUrl = url ||
+        (nightly ? await (0, utils_1.getBranch)('main') : '') ||
+        (branch ? await (0, utils_1.getBranch)(branch) : '') ||
+        (tag ? await (0, utils_1.getTag)(tag) : await (0, utils_1.getLatest)());
+    console.log(`Fetching ${locationUrl}...`);
+    const response = await (0, fetchWithProxy_1.default)(locationUrl);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} fetching ${locationUrl}: ${response.statusText}`);
+    }
+    const type = response.headers.get('content-type');
+    if (url &&
+        type !== 'application/zip' &&
+        type !== 'application/octet-stream') {
+        throw new Error('The URL provided does not seem to be a JBrowse installation URL');
+    }
+    if (clean) {
+        fs_1.default.rmSync(path_1.default.join(argsPath, 'static'), { recursive: true, force: true });
+        for (const f of fs_1.default
+            .readdirSync(argsPath)
+            .filter(f => f.includes('worker.js'))) {
+            fs_1.default.unlinkSync(path_1.default.join(argsPath, f));
+        }
+    }
+    await (0, decompress_1.default)(Buffer.from(await response.arrayBuffer()), argsPath);
+    console.log(`Unpacked ${locationUrl} at ${argsPath}`);
+}

package/dist/fetchWithProxy.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = fetchWithProxy;
+const node_1 = require("node-fetch-native/node");
+const proxy_1 = require("node-fetch-native/proxy");
+const proxy = (0, proxy_1.createProxy)();
+// The correct proxy `Agent` implementation to use will be determined
+// via the `http_proxy` / `https_proxy` / `no_proxy` / etc. env vars
+// https://github.com/unjs/node-fetch-native?tab=readme-ov-file#proxy-support
+function fetchWithProxy(url, options = {}) {
+    return (0, node_1.fetch)(url, { ...options, ...proxy });
+}

package/dist/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const util_1 = require("util");
+// Command imports
+const add_assembly_1 = require("./commands/add-assembly");
+const add_connection_1 = require("./commands/add-connection");
+const add_track_1 = require("./commands/add-track");
+const add_track_json_1 = require("./commands/add-track-json");
+const admin_server_1 = require("./commands/admin-server");
+const create_1 = require("./commands/create");
+const make_pif_1 = require("./commands/make-pif");
+const remove_track_1 = require("./commands/remove-track");
+const set_default_session_1 = require("./commands/set-default-session");
+const sort_bed_1 = require("./commands/sort-bed");
+const sort_gff_1 = require("./commands/sort-gff");
+const text_index_1 = require("./commands/text-index");
+const upgrade_1 = require("./commands/upgrade");
+const commands = {
+    create: create_1.run,
+    'add-assembly': add_assembly_1.run,
+    'add-track': add_track_1.run,
+    'text-index': text_index_1.run,
+    'admin-server': admin_server_1.run,
+    upgrade: upgrade_1.run,
+    'make-pif': make_pif_1.run,
+    'sort-gff': sort_gff_1.run,
+    'sort-bed': sort_bed_1.run,
+    'add-connection': add_connection_1.run,
+    'add-track-json': add_track_json_1.run,
+    'remove-track': remove_track_1.run,
+    'set-default-session': set_default_session_1.run,
+};
+async function main(args) {
+    try {
+        const { values: flags, positionals } = (0, util_1.parseArgs)({
+            args,
+            options: {
+                help: {
+                    type: 'boolean',
+                    short: 'h',
+                    default: false,
+                },
+                version: {
+                    type: 'boolean',
+                    short: 'v',
+                    default: false,
+                },
+            },
+            allowPositionals: true,
+            strict: false, // Allow unknown flags to be passed to subcommands
+        });
+        // Check if help or version is requested at the global level
+        if (flags.help && positionals.length === 0) {
+            showGlobalHelp();
+            return;
+        }
+        if (flags.version && positionals.length === 0) {
+            const packageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '../package.json'), 'utf8'));
+            console.log(`@jbrowse/cli version ${packageJson.version}`);
+            return;
+        }
+        const commandName = positionals[0];
+        if (!commandName) {
+            console.error('Error: Missing command');
+            showGlobalHelp();
+            process.exit(1);
+        }
+        const command = commands[commandName];
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (!command) {
+            console.error(`Error: Unknown command "${commandName}"`);
+            console.error(`Available commands: ${Object.keys(commands).join(', ')}`);
+            process.exit(1);
+        }
+        // Pass the remaining arguments to the command
+        const commandArgs = args.slice(1); // Remove the command name from args
+        await command(commandArgs);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function showGlobalHelp() {
+    console.log(`
+JBrowse CLI
+
+USAGE
+  $ jbrowse <command> [options]
+
+COMMANDS
+  create               Downloads and installs the latest JBrowse 2 release
+  add-assembly         Add an assembly to a JBrowse 2 configuration
+  add-track            Add a track to a JBrowse 2 configuration
+  text-index           Make a text-indexing file for any given track(s)
+  admin-server         Start up a small admin server for JBrowse configuration
+  upgrade              Upgrades JBrowse 2 to latest version
+  make-pif             Creates pairwise indexed PAF (PIF), with bgzip and tabix
+  sort-gff             Helper utility to sort GFF files for tabix
+  sort-bed             Helper utility to sort BED files for tabix
+  add-connection       Add a connection to a JBrowse 2 configuration
+  add-track-json       Add a track configuration directly from a JSON hunk
+  remove-track         Remove a track configuration from a JBrowse 2 configuration
+  set-default-session  Set a default session with views and tracks
+
+OPTIONS
+  -h, --help     Show help
+  -v, --version  Show version
+
+Use "jbrowse <command> --help" for more information about a command.
+`);
+}

package/dist/types/common.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteStream = createRemoteStream;
+exports.isURL = isURL;
+exports.guessAdapterFromFileName = guessAdapterFromFileName;
+exports.supported = supported;
+exports.generateMeta = generateMeta;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const fetchWithProxy_1 = __importDefault(require("../fetchWithProxy"));
+async function createRemoteStream(urlIn) {
+    const res = await (0, fetchWithProxy_1.default)(urlIn);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch ${urlIn} status ${res.status} ${await res.text()}`);
+    }
+    return res;
+}
+function isURL(FileName) {
+    let url;
+    try {
+        url = new URL(FileName);
+    }
+    catch (_) {
+        return false;
+    }
+    return url.protocol === 'http:' || url.protocol === 'https:';
+}
+function makeLocation(location, protocol) {
+    if (protocol === 'uri') {
+        return {
+            uri: location,
+            locationType: 'UriLocation',
+        };
+    }
+    if (protocol === 'localPath') {
+        return {
+            localPath: path_1.default.resolve(location),
+            locationType: 'LocalPathLocation',
+        };
+    }
+    throw new Error(`invalid protocol ${protocol}`);
+}
+function guessAdapterFromFileName(filePath) {
+    const protocol = isURL(filePath) ? 'uri' : 'localPath';
+    const name = path_1.default.basename(filePath);
+    if (/\.vcf\.b?gz$/i.test(filePath)) {
+        return {
+            trackId: name,
+            name: name,
+            assemblyNames: [],
+            adapter: {
+                type: 'VcfTabixAdapter',
+                vcfGzLocation: makeLocation(filePath, protocol),
+            },
+        };
+    }
+    else if (/\.gff3?\.b?gz$/i.test(filePath)) {
+        return {
+            trackId: name,
+            name,
+            assemblyNames: [],
+            adapter: {
+                type: 'Gff3TabixAdapter',
+                gffGzLocation: makeLocation(filePath, protocol),
+            },
+        };
+    }
+    else if (/\.gtf?$/i.test(filePath)) {
+        return {
+            trackId: name,
+            name,
+            assemblyNames: [],
+            adapter: {
+                type: 'GtfAdapter',
+                gtfLocation: { uri: filePath, locationType: 'UriLocation' },
+            },
+        };
+    }
+    else if (/\.vcf$/i.test(filePath)) {
+        return {
+            trackId: name,
+            name,
+            assemblyNames: [],
+            adapter: {
+                type: 'VcfAdapter',
+                vcfLocation: makeLocation(filePath, protocol),
+            },
+        };
+    }
+    else if (/\.gff3?$/i.test(filePath)) {
+        return {
+            trackId: name,
+            name,
+            assemblyNames: [],
+            adapter: {
+                type: 'Gff3Adapter',
+                gffLocation: makeLocation(filePath, protocol),
+            },
+        };
+    }
+    else {
+        throw new Error(`Unsupported file type ${filePath}`);
+    }
+}
+function supported(type = '') {
+    return [
+        'Gff3TabixAdapter',
+        'VcfTabixAdapter',
+        'Gff3Adapter',
+        'VcfAdapter',
+    ].includes(type);
+}
+async function generateMeta({ trackConfigs, attributes, outLocation, name, typesToExclude, assemblyNames, }) {
+    const tracks = trackConfigs.map(({ adapter, textSearching, trackId }) => ({
+        trackId,
+        attributesIndexed: textSearching?.indexingAttributes || attributes,
+        excludedTypes: textSearching?.indexingFeatureTypesToExclude || typesToExclude,
+        adapterConf: adapter,
+    }));
+    fs_1.default.writeFileSync(path_1.default.join(outLocation, 'trix', `${name}_meta.json`), JSON.stringify({
+        dateCreated: new Date().toISOString(),
+        tracks,
+        assemblyNames,
+    }, null, 2));
+}

package/dist/types/gff3Adapter.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexGff3 = indexGff3;
+const readline_1 = __importDefault(require("readline"));
+const zlib_1 = require("zlib");
+const cli_progress_1 = require("cli-progress");
+const util_1 = require("../util");
+async function* indexGff3({ config, attributesToIndex, inLocation, outLocation, typesToExclude, quiet, }) {
+    const { trackId } = config;
+    // progress bar code was aided by blog post at
+    // https://webomnizz.com/download-a-file-with-progressbar-using-node-js/
+    const progressBar = new cli_progress_1.SingleBar({
+        format: `{bar} ${trackId} {percentage}% | ETA: {eta}s`,
+        etaBuffer: 2000,
+    }, cli_progress_1.Presets.shades_classic);
+    let receivedBytes = 0;
+    const { totalBytes, stream } = await (0, util_1.getLocalOrRemoteStream)(inLocation, outLocation);
+    if (!quiet) {
+        progressBar.start(totalBytes, 0);
+    }
+    // @ts-expect-error
+    stream.on('data', chunk => {
+        receivedBytes += chunk.length;
+        progressBar.update(receivedBytes);
+    });
+    const rl = readline_1.default.createInterface({
+        // @ts-expect-error
+        input: /.b?gz$/.exec(inLocation) ? stream.pipe((0, zlib_1.createGunzip)()) : stream,
+    });
+    for await (const line of rl) {
+        if (!line.trim()) {
+            continue;
+        }
+        else if (line.startsWith('#')) {
+            continue;
+        }
+        else if (line.startsWith('>')) {
+            break;
+        }
+        const [seq_id, , type, start, end, , , , col9] = line.split('\t');
+        const locStr = `${seq_id}:${start}..${end}`;
+        if (!typesToExclude.includes(type)) {
+            // turns gff3 attrs into a map, and converts the arrays into space
+            // separated strings
+            const col9attrs = Object.fromEntries(col9
+                .split(';')
+                .map(f => f.trim())
+                .filter(f => !!f)
+                .map(f => f.split('='))
+                .map(([key, val]) => [
+                key.trim(),
+                val
+                    ? (0, util_1.decodeURIComponentNoThrow)(val).trim().split(',').join(' ')
+                    : undefined,
+            ]));
+            const attrs = attributesToIndex
+                .map(attr => col9attrs[attr])
+                .filter((f) => !!f);
+            if (attrs.length) {
+                const record = JSON.stringify([
+                    encodeURIComponent(locStr),
+                    encodeURIComponent(trackId),
+                    ...attrs.map(a => encodeURIComponent(a)),
+                ]).replaceAll(',', '|');
+                yield `${record} ${[...new Set(attrs)].join(' ')}\n`;
+            }
+        }
+    }
+    progressBar.stop();
+}

package/dist/types/vcfAdapter.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexVcf = indexVcf;
+const readline_1 = __importDefault(require("readline"));
+const zlib_1 = require("zlib");
+const cli_progress_1 = require("cli-progress");
+const util_1 = require("../util");
+async function* indexVcf({ config, attributesToIndex, inLocation, outLocation, quiet, }) {
+    const { trackId } = config;
+    // progress bar code was aided by blog post at
+    // https://webomnizz.com/download-a-file-with-progressbar-using-node-js/
+    const progressBar = new cli_progress_1.SingleBar({
+        format: `{bar} ${trackId} {percentage}% | ETA: {eta}s`,
+        etaBuffer: 2000,
+    }, cli_progress_1.Presets.shades_classic);
+    let receivedBytes = 0;
+    const { totalBytes, stream } = await (0, util_1.getLocalOrRemoteStream)(inLocation, outLocation);
+    if (!quiet) {
+        progressBar.start(totalBytes, 0);
+    }
+    // @ts-expect-error
+    stream.on('data', chunk => {
+        receivedBytes += chunk.length;
+        progressBar.update(receivedBytes);
+    });
+    const gzStream = /.b?gz$/.exec(inLocation)
+        ? // @ts-expect-error
+            stream.pipe((0, zlib_1.createGunzip)())
+        : stream;
+    const rl = readline_1.default.createInterface({
+        input: gzStream,
+    });
+    for await (const line of rl) {
+        if (line.startsWith('#')) {
+            continue;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const [ref, pos, id, _ref, _alt, _qual, _filter, info] = line.split('\t');
+        // turns gff3 attrs into a map, and converts the arrays into space
+        // separated strings
+        const fields = Object.fromEntries(info
+            .split(';')
+            .map(f => f.trim())
+            .filter(f => !!f)
+            .map(f => f.split('='))
+            .map(([key, val]) => [
+            key.trim(),
+            val
+                ? (0, util_1.decodeURIComponentNoThrow)(val).trim().split(',').join(' ')
+                : undefined,
+        ]));
+        const end = fields.END;
+        const locStr = `${ref}:${pos}..${end || +pos + 1}`;
+        if (id === '.') {
+            continue;
+        }
+        const infoAttrs = attributesToIndex
+            .map(attr => fields[attr])
+            .filter((f) => !!f);
+        const ids = id.split(',');
+        for (const id of ids) {
+            const attrs = [id];
+            const record = JSON.stringify([
+                encodeURIComponent(locStr),
+                encodeURIComponent(trackId),
+                encodeURIComponent(id || ''),
+                ...infoAttrs.map(a => encodeURIComponent(a || '')),
+            ]).replaceAll(',', '|');
+            yield `${record} ${[...new Set(attrs)].join(' ')}\n`;
+        }
+    }
+    progressBar.stop();
+}

package/dist/util.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalOrRemoteStream = getLocalOrRemoteStream;
+exports.decodeURIComponentNoThrow = decodeURIComponentNoThrow;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const common_1 = require("./types/common");
+async function getLocalOrRemoteStream(uri, out) {
+    if ((0, common_1.isURL)(uri)) {
+        const result = await (0, common_1.createRemoteStream)(uri);
+        return {
+            totalBytes: +(result.headers.get('Content-Length') || 0),
+            stream: result.body,
+        };
+    }
+    else {
+        const filename = path_1.default.isAbsolute(uri) ? uri : path_1.default.join(out, uri);
+        return {
+            totalBytes: fs_1.default.statSync(filename).size,
+            stream: fs_1.default.createReadStream(filename),
+        };
+    }
+}
+function decodeURIComponentNoThrow(uri) {
+    try {
+        return decodeURIComponent(uri);
+    }
+    catch (e) {
+        // avoid throwing exception on a failure to decode URI component
+        return uri;
+    }
+}