@jbrowse/cli 4.0.4 → 4.1.3

package/dist/commands/upgrade.js

@@ -1,15 +1,9 @@
-"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_ts_1 = __importDefault(require("../fetchWithProxy.js"));
-const utils_ts_1 = require("../utils.js");
+import fs from 'fs';
+import path from 'path';
+import { parseArgs } from 'util';
+import decompress from 'decompress';
+import fetch from "../cliFetch.js";
+import { fetchGithubVersions, getBranch, getLatest, getTag, printHelp, } from "../utils.js";
 const description = 'Upgrades JBrowse 2 to latest version';
 const examples = [
     '# Upgrades current directory to latest jbrowse release',
@@ -45,7 +39,7 @@ const options = {
     tag: {
         type: 'string',
         short: 't',
-        description: 'Version of JBrowse 2 to install. Format is v1.0.0.\nDefaults to latest',
+        description: 'Version of JBrowse 2 to install. Format is v1.0.0. Defaults to latest',
     },
     branch: {
         type: 'string',
@@ -65,8 +59,8 @@ const options = {
         description: 'A direct URL to a JBrowse 2 release',
     },
 };
-async function run(args) {
-    const { positionals, values: runFlags } = (0, util_1.parseArgs)({
+export async function run(args) {
+    const { positionals, values: runFlags } = parseArgs({
         options,
         args,
         allowPositionals: true,
@@ -74,7 +68,7 @@ async function run(args) {
     const argsPath = positionals[0];
     const { clean, listVersions, tag, url, branch, nightly } = runFlags;
     if (runFlags.help) {
-        (0, utils_ts_1.printHelp)({
+        printHelp({
             options,
             examples,
             usage: 'jbrowse upgrade [localPath] [options]',
@@ -83,23 +77,23 @@ async function run(args) {
         return;
     }
     if (listVersions) {
-        const versions = (await (0, utils_ts_1.fetchGithubVersions)()).map(v => v.tag_name);
+        const versions = (await 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'))) {
+    if (!fs.existsSync(path.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_ts_1.getBranch)('main') : '') ||
-        (branch ? await (0, utils_ts_1.getBranch)(branch) : '') ||
-        (tag ? await (0, utils_ts_1.getTag)(tag) : await (0, utils_ts_1.getLatest)());
+        (nightly ? await getBranch('main') : '') ||
+        (branch ? await getBranch(branch) : '') ||
+        (tag ? await getTag(tag) : await getLatest());
     console.log(`Fetching ${locationUrl}...`);
-    const response = await (0, fetchWithProxy_ts_1.default)(locationUrl);
+    const response = await fetch(locationUrl);
     if (!response.ok) {
         throw new Error(`HTTP ${response.status} fetching ${locationUrl}: ${response.statusText}`);
     }
@@ -110,13 +104,13 @@ async function run(args) {
         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
+        fs.rmSync(path.join(argsPath, 'static'), { recursive: true, force: true });
+        for (const f of fs
             .readdirSync(argsPath)
             .filter(f => f.includes('worker.js'))) {
-            fs_1.default.unlinkSync(path_1.default.join(argsPath, f));
+            fs.unlinkSync(path.join(argsPath, f));
         }
     }
-    await (0, decompress_1.default)(Buffer.from(await response.arrayBuffer()), argsPath);
+    await decompress(Buffer.from(await response.arrayBuffer()), argsPath);
     console.log(`Unpacked ${locationUrl} at ${argsPath}`);
 }

package/dist/index.js

@@ -1,45 +1,38 @@
 #!/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");
+import { parseArgs } from 'util';
 // Command imports
-const index_ts_1 = require("./commands/add-assembly/index.js");
-const add_connection_ts_1 = require("./commands/add-connection.js");
-const add_track_json_ts_1 = require("./commands/add-track-json.js");
-const add_track_ts_1 = require("./commands/add-track.js");
-const index_ts_2 = require("./commands/admin-server/index.js");
-const create_ts_1 = require("./commands/create.js");
-const index_ts_3 = require("./commands/make-pif/index.js");
-const remove_track_ts_1 = require("./commands/remove-track.js");
-const set_default_session_ts_1 = require("./commands/set-default-session.js");
-const sort_bed_ts_1 = require("./commands/sort-bed.js");
-const sort_gff_ts_1 = require("./commands/sort-gff.js");
-const index_ts_4 = require("./commands/text-index/index.js");
-const upgrade_ts_1 = require("./commands/upgrade.js");
+import { run as addAssemblyRun } from "./commands/add-assembly/index.js";
+import { run as addConnectionRun } from "./commands/add-connection.js";
+import { run as addTrackJsonRun } from "./commands/add-track-json.js";
+import { run as addTrackRun } from "./commands/add-track.js";
+import { run as adminServerRun } from "./commands/admin-server/index.js";
+import { run as createRun } from "./commands/create.js";
+import { run as makePIFRun } from "./commands/make-pif/index.js";
+import { run as removeTrackRun } from "./commands/remove-track.js";
+import { run as setDefaultSessionRun } from "./commands/set-default-session.js";
+import { run as sortBedRun } from "./commands/sort-bed.js";
+import { run as sortGffRun } from "./commands/sort-gff.js";
+import { run as textIndexRun } from "./commands/text-index/index.js";
+import { run as upgradeRun } from "./commands/upgrade.js";
+import { version } from "./version.js";
 const commands = {
-    create: create_ts_1.run,
-    'add-assembly': index_ts_1.run,
-    'add-track': add_track_ts_1.run,
-    'text-index': index_ts_4.run,
-    'admin-server': index_ts_2.run,
-    upgrade: upgrade_ts_1.run,
-    'make-pif': index_ts_3.run,
-    'sort-gff': sort_gff_ts_1.run,
-    'sort-bed': sort_bed_ts_1.run,
-    'add-connection': add_connection_ts_1.run,
-    'add-track-json': add_track_json_ts_1.run,
-    'remove-track': remove_track_ts_1.run,
-    'set-default-session': set_default_session_ts_1.run,
+    create: createRun,
+    'add-assembly': addAssemblyRun,
+    'add-track': addTrackRun,
+    'text-index': textIndexRun,
+    'admin-server': adminServerRun,
+    upgrade: upgradeRun,
+    'make-pif': makePIFRun,
+    'sort-gff': sortGffRun,
+    'sort-bed': sortBedRun,
+    'add-connection': addConnectionRun,
+    'add-track-json': addTrackJsonRun,
+    'remove-track': removeTrackRun,
+    'set-default-session': setDefaultSessionRun,
 };
-async function main(args) {
+export async function main(args) {
     try {
-        const { values: flags, positionals } = (0, util_1.parseArgs)({
+        const { values: flags, positionals } = parseArgs({
             args,
             options: {
                 help: {
@@ -62,8 +55,7 @@ async function main(args) {
             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}`);
+            console.log(`@jbrowse/cli version ${version}`);
             return;
         }
         const commandName = positionals[0];

package/dist/types/common.js

@@ -1,24 +1,12 @@
-"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_ts_1 = __importDefault(require("../fetchWithProxy.js"));
-async function createRemoteStream(urlIn) {
-    const res = await (0, fetchWithProxy_ts_1.default)(urlIn);
+import fetch from "../cliFetch.js";
+export async function createRemoteStream(urlIn) {
+    const res = await fetch(urlIn);
     if (!res.ok) {
         throw new Error(`Failed to fetch ${urlIn} status ${res.status} ${await res.text()}`);
     }
     return res;
 }
-function isURL(FileName) {
+export function isURL(FileName) {
     let url;
     try {
         url = new URL(FileName);
@@ -28,102 +16,12 @@ function isURL(FileName) {
     }
     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}`);
-    }
-}
 const SUPPORTED_ADAPTERS = new Set([
     'Gff3TabixAdapter',
     'VcfTabixAdapter',
     'Gff3Adapter',
     'VcfAdapter',
 ]);
-function supported(type = '') {
+export function supported(type = '') {
     return SUPPORTED_ADAPTERS.has(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/util.js

@@ -1,34 +1,27 @@
-"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 = require("fs");
-const promises_1 = require("fs/promises");
-const path_1 = __importDefault(require("path"));
-const stream_1 = require("stream");
-const common_ts_1 = require("./types/common.js");
-async function getLocalOrRemoteStream(uri, out) {
-    if ((0, common_ts_1.isURL)(uri)) {
-        const result = await (0, common_ts_1.createRemoteStream)(uri);
+import { createReadStream } from 'fs';
+import { stat } from 'fs/promises';
+import path from 'path';
+import { Readable } from 'stream';
+import { createRemoteStream, isURL } from "./types/common.js";
+export async function getLocalOrRemoteStream(uri, out) {
+    if (isURL(uri)) {
+        const result = await 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);
-        const stats = await (0, promises_1.stat)(filename);
-        const nodeStream = (0, fs_1.createReadStream)(filename);
+        const filename = path.isAbsolute(uri) ? uri : path.join(out, uri);
+        const stats = await stat(filename);
+        const nodeStream = createReadStream(filename);
         return {
             totalBytes: stats.size,
-            stream: stream_1.Readable.toWeb(nodeStream),
+            stream: Readable.toWeb(nodeStream),
         };
     }
 }
-function decodeURIComponentNoThrow(uri) {
+export function decodeURIComponentNoThrow(uri) {
     if (!uri.includes('%')) {
         return uri;
     }

package/dist/utils.js

@@ -1,47 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.debug = debug;
-exports.resolveConfigPath = resolveConfigPath;
-exports.readFile = readFile;
-exports.readJsonFile = readJsonFile;
-exports.writeJsonFile = writeJsonFile;
-exports.resolveFileLocation = resolveFileLocation;
-exports.readInlineOrFileJson = readInlineOrFileJson;
-exports.fetchGithubVersions = fetchGithubVersions;
-exports.getLatest = getLatest;
-exports.fetchVersions = fetchVersions;
-exports.getTag = getTag;
-exports.getBranch = getBranch;
-exports.printHelp = printHelp;
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const json_parse_better_errors_1 = __importDefault(require("json-parse-better-errors"));
-const fetchWithProxy_ts_1 = __importDefault(require("./fetchWithProxy.js"));
-function debug(message) {
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import parseJSON from 'json-parse-better-errors';
+import fetch from "./cliFetch.js";
+export function debug(message) {
     if (process.env.DEBUG) {
         console.log(`DEBUG: ${message}`);
     }
 }
-async function resolveConfigPath(target, out) {
+export async function resolveConfigPath(target, out) {
     const output = target || out || '.';
-    const stat = await fs_1.promises.lstat(output);
+    const stat = await fsPromises.lstat(output);
     return stat.isDirectory() ? `${output}/config.json` : output;
 }
-async function readFile(location) {
-    return fs_1.promises.readFile(location, { encoding: 'utf8' });
+export async function readFile(location) {
+    return fsPromises.readFile(location, { encoding: 'utf8' });
 }
-async function readJsonFile(location) {
-    const contents = await fs_1.promises.readFile(location, { encoding: 'utf8' });
-    return (0, json_parse_better_errors_1.default)(contents);
+export async function readJsonFile(location) {
+    const contents = await fsPromises.readFile(location, { encoding: 'utf8' });
+    return parseJSON(contents);
 }
-async function writeJsonFile(location, contents) {
+export async function writeJsonFile(location, contents) {
     debug(`Writing JSON file to ${process.cwd()} ${location}`);
-    return fs_1.promises.writeFile(location, JSON.stringify(contents, null, 2));
+    return fsPromises.writeFile(location, JSON.stringify(contents, null, 2));
 }
-async function resolveFileLocation(location, check = true, inPlace = false) {
+export async function resolveFileLocation(location, check = true, inPlace = false) {
     let locationUrl;
     try {
         locationUrl = new URL(location);
@@ -51,7 +33,7 @@ async function resolveFileLocation(location, check = true, inPlace = false) {
     }
     if (locationUrl) {
         if (check) {
-            const response = await (0, fetchWithProxy_ts_1.default)(locationUrl, { method: 'HEAD' });
+            const response = await fetch(locationUrl, { method: 'HEAD' });
             if (!response.ok) {
                 throw new Error(`${locationUrl} result ${response.statusText}`);
             }
@@ -60,13 +42,13 @@ async function resolveFileLocation(location, check = true, inPlace = false) {
     }
     let locationPath;
     try {
-        locationPath = check ? await fs_1.promises.realpath(location) : location;
+        locationPath = check ? await fsPromises.realpath(location) : location;
     }
     catch (e) {
         // ignore
     }
     if (locationPath) {
-        const filePath = path_1.default.relative(process.cwd(), locationPath);
+        const filePath = path.relative(process.cwd(), locationPath);
         if (inPlace && filePath.startsWith('..')) {
             console.warn(`Location ${filePath} is not in the JBrowse directory. Make sure it is still in your server directory.`);
         }
@@ -74,11 +56,11 @@ async function resolveFileLocation(location, check = true, inPlace = false) {
     }
     throw new Error(`Could not resolve to a file or a URL: "${location}"`);
 }
-async function readInlineOrFileJson(inlineOrFileName) {
+export async function readInlineOrFileJson(inlineOrFileName) {
     let result;
     // see if it's inline JSON
     try {
-        result = (0, json_parse_better_errors_1.default)(inlineOrFileName);
+        result = parseJSON(inlineOrFileName);
     }
     catch (error) {
         debug(`Not valid inline JSON, attempting to parse as filename: '${inlineOrFileName}'`);
@@ -87,23 +69,23 @@ async function readInlineOrFileJson(inlineOrFileName) {
     }
     return result;
 }
-async function fetchGithubVersions() {
+export async function fetchGithubVersions() {
     let versions = [];
     for await (const iter of fetchVersions()) {
         versions = [...versions, ...iter];
     }
     return versions;
 }
-async function getLatest() {
+export async function getLatest() {
     for await (const versions of fetchVersions()) {
         // if a release was just uploaded, or an erroneous build was made then it
         // might have no build asset
-        const nonprereleases = versions
+        const nonprerelease = versions
             .filter(release => !release.prerelease)
-            .filter(release => release.assets?.length);
-        if (nonprereleases.length > 0) {
-            // @ts-expect-error
-            const file = nonprereleases[0].assets.find(f => f.name.includes('jbrowse-web'))?.browser_download_url;
+            .find(release => release.assets?.length);
+        const first = nonprerelease;
+        if (first?.assets) {
+            const file = first.assets.find(f => f.name.includes('jbrowse-web'))?.browser_download_url;
             if (!file) {
                 throw new Error('no jbrowse-web download found');
             }
@@ -112,12 +94,12 @@ async function getLatest() {
     }
     throw new Error('no version tags found');
 }
-async function* fetchVersions() {
+export async function* fetchVersions() {
     let page = 1;
     let result;
     do {
         const url = `https://api.github.com/repos/GMOD/jbrowse-components/releases?page=${page}`;
-        const response = await (0, fetchWithProxy_ts_1.default)(url);
+        const response = await fetch(url);
         if (response.ok) {
             result = (await response.json());
             yield result.filter(release => release.tag_name.startsWith('v'));
@@ -128,8 +110,8 @@ async function* fetchVersions() {
         }
     } while (result.length);
 }
-async function getTag(tag) {
-    const response = await (0, fetchWithProxy_ts_1.default)(`https://api.github.com/repos/GMOD/jbrowse-components/releases/tags/${tag}`);
+export async function getTag(tag) {
+    const response = await fetch(`https://api.github.com/repos/GMOD/jbrowse-components/releases/tags/${tag}`);
     if (response.ok) {
         const result = (await response.json());
         const file = result.assets?.find(f => f.name.includes('jbrowse-web'))?.browser_download_url;
@@ -140,20 +122,62 @@ async function getTag(tag) {
     }
     throw new Error(`Could not find version: ${response.statusText}`);
 }
-async function getBranch(branch) {
+export async function getBranch(branch) {
     return `https://s3.amazonaws.com/jbrowse.org/code/jb2/${branch}/jbrowse-web-${branch}.zip`;
 }
-function printHelp({ description, options, examples, usage, }) {
+function wrapText(text, width, indent) {
+    // Normalize: join single \n into spaces, preserve \n\n as paragraph breaks
+    const normalized = text
+        .replace(/\n\n/g, '\0')
+        .replace(/\n/g, ' ')
+        .replace(/\0/g, '\n\n');
+    const lines = [];
+    for (const line of normalized.split('\n')) {
+        if (line.length <= width) {
+            lines.push(line);
+        }
+        else {
+            const words = line.split(' ');
+            let current = '';
+            for (const word of words) {
+                if (current.length + word.length + 1 <= width) {
+                    current += (current ? ' ' : '') + word;
+                }
+                else {
+                    if (current) {
+                        lines.push(current);
+                    }
+                    current = word;
+                }
+            }
+            if (current) {
+                lines.push(current);
+            }
+        }
+    }
+    return lines.join(`\n${indent}`);
+}
+export function printHelp({ description, options, examples, usage, }) {
+    const termWidth = process.stdout.columns || 80;
     console.log(description);
     console.log(`\nUsage: ${usage || 'jbrowse <command> [options]'}`);
     console.log('\nOptions:');
     for (const [name, option] of Object.entries(options)) {
-        const short = 'short' in option && option.short
-            ? `-${option.short}`
-            : '   ';
-        const namePadded = `--${name}`.padEnd(25, ' ');
-        const desc = option.description?.replace(/\n/g, `\n${' '.repeat(29)}`);
-        console.log(`  ${short}, ${namePadded} ${desc}`);
+        const opt = option;
+        const shortFlag = opt.short;
+        const prefix = shortFlag ? `  -${shortFlag}, ` : '      ';
+        const namePadded = `--${name}`.padEnd(22, ' ');
+        const indent = ' '.repeat(prefix.length + namePadded.length + 1);
+        const descWidth = termWidth - indent.length;
+        let desc = opt.description || '';
+        if (opt.choices) {
+            desc += ` [choices: ${opt.choices.join(', ')}]`;
+        }
+        if (opt.default !== undefined) {
+            desc += ` [default: ${opt.default}]`;
+        }
+        const wrapped = desc ? wrapText(desc, descWidth, indent) : '';
+        console.log(`${prefix}${namePadded} ${wrapped}\n`);
     }
-    console.log(`\n${examples.join('\n')}`);
+    console.log(examples.join('\n'));
 }

package/dist/version.js

@@ -0,0 +1 @@
+export const version = '4.1.3';

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@jbrowse/cli",
-  "version": "4.0.4",
+  "version": "4.1.3",
+  "type": "module",
   "description": "A command line tool for working with JBrowse 2",
   "keywords": [
     "jbrowse",
@@ -30,20 +31,20 @@
   "dependencies": {
     "cli-progress": "^3.12.0",
     "command-exists": "^1.2.9",
-    "cors": "^2.8.5",
+    "cors": "^2.8.6",
     "decompress": "^4.2.1",
     "express": "^5.2.1",
-    "ixixx": "^3.0.2",
+    "ixixx": "^3.0.3",
     "json-parse-better-errors": "^1.0.2",
-    "node-fetch-native": "^1.6.7",
-    "tmp": "^0.2.5"
+    "tmp": "^0.2.5",
+    "@jbrowse/text-indexing-core": "^4.1.3"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "prebuild": "pnpm clean",
-    "build": "tsc && webpack",
+    "build": "tsc && webpack -c webpack.config.mjs",
     "clean": "rimraf bundle",
     "generate-readme": "./generate_readme.sh > README.md"
   }

package/dist/fetchWithProxy.js

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