@jbrowse/core 2.17.0 → 3.0.0

package/util/blockTypes.js

@@ -24,11 +24,9 @@ class BlockSet {
         return this.blocks.map(block => block.toRegion());
     }
     map(func, thisarg) {
-        // eslint-disable-next-line unicorn/no-array-method-this-argument
         return this.blocks.map(func, thisarg);
     }
     forEach(func, thisarg) {
-        // eslint-disable-next-line unicorn/no-array-method-this-argument
         this.blocks.forEach(func, thisarg);
     }
     get length() {
@@ -58,9 +56,6 @@ class BlockSet {
 }
 exports.BlockSet = BlockSet;
 class BaseBlock {
-    /**
-     * a block that should be shown as filled with data
-     */
     constructor(data) {
         this.type = 'BaseBlock';
         this.widthPx = 0;
@@ -90,10 +85,6 @@ class ContentBlock extends BaseBlock {
     }
 }
 exports.ContentBlock = ContentBlock;
-/**
- * marker block representing one or more blocks that are
- * too small to be shown at the current zoom level
- */
 class ElidedBlock extends BaseBlock {
     constructor(data) {
         super(data);
@@ -110,10 +101,6 @@ class ElidedBlock extends BaseBlock {
     }
 }
 exports.ElidedBlock = ElidedBlock;
-/**
- * marker block that sits between two different displayed regions
- * and provides a thick border between them
- */
 class InterRegionPaddingBlock extends BaseBlock {
     constructor() {
         super(...arguments);

package/util/calculateDynamicBlocks.d.ts

@@ -1,22 +1,3 @@
 import { BlockSet } from './blockTypes';
-import { Base1DViewModel } from './calculateStaticBlocks';
-/**
- * returns a BlockSet of which the `blocks` attribute is an array of 'dynamic
- * blocks', which are blocks representing only the regions that are visible in
- * the view right now. these are mostly used by tracks for which static blocks
- * are not feasible.
- *
- * each block is a plain JS object like:
- *   `{ refName, start, end, offsetPx, reversed? }`
- *
- * start and end are in bp, and start is always less than end, but if reversed
- * is true, startBp will be on the right side of the visible region.
- *
- * offsetPx is the number of pixels from the left edge of the view to the left
- * edge of the region
- *
- * NOTE: start, end, and offsetPx may all be fractional!
- *
- * @returns BlockSet of `{ refName, startBp, end, offset, reversed? }`
- */
+import type { Base1DViewModel } from './calculateStaticBlocks';
 export default function calculateDynamicBlocks(model: Base1DViewModel, padding?: boolean, elision?: boolean): BlockSet;

package/util/calculateDynamicBlocks.js

@@ -2,28 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = calculateDynamicBlocks;
 const mobx_state_tree_1 = require("mobx-state-tree");
-const range_1 = require("./range");
 const _1 = require(".");
 const blockTypes_1 = require("./blockTypes");
-/**
- * returns a BlockSet of which the `blocks` attribute is an array of 'dynamic
- * blocks', which are blocks representing only the regions that are visible in
- * the view right now. these are mostly used by tracks for which static blocks
- * are not feasible.
- *
- * each block is a plain JS object like:
- *   `{ refName, start, end, offsetPx, reversed? }`
- *
- * start and end are in bp, and start is always less than end, but if reversed
- * is true, startBp will be on the right side of the visible region.
- *
- * offsetPx is the number of pixels from the left edge of the view to the left
- * edge of the region
- *
- * NOTE: start, end, and offsetPx may all be fractional!
- *
- * @returns BlockSet of `{ refName, startBp, end, offset, reversed? }`
- */
+const range_1 = require("./range");
 function calculateDynamicBlocks(model, padding = true, elision = true) {
     const { offsetPx, displayedRegions, bpPerPx, width, minimumBlockWidth, interRegionPaddingWidth, } = model;
     if (!width) {
@@ -41,7 +22,6 @@ function calculateDynamicBlocks(model, padding = true, elision = true) {
         const parentRegion = (0, mobx_state_tree_1.isStateTreeNode)(region) ? (0, mobx_state_tree_1.getSnapshot)(region) : region;
         const [leftPx, rightPx] = (0, range_1.intersection2)(windowLeftPx, windowRightPx, displayedRegionLeftPx, displayedRegionRightPx);
         if (leftPx !== undefined && rightPx !== undefined) {
-            // this displayed region overlaps the view, so make a record for it
             let start;
             let end;
             let isLeftEndOfDisplayedRegion;
@@ -92,7 +72,6 @@ function calculateDynamicBlocks(model, padding = true, elision = true) {
                 blocks.push(new blockTypes_1.ContentBlock(blockData));
             }
             if (padding) {
-                // insert a inter-region padding block if we are crossing a displayed region
                 if (regionWidthPx >= minimumBlockWidth &&
                     blockData.isRightEndOfDisplayedRegion &&
                     regionNumber < displayedRegions.length - 1) {

package/util/calculateStaticBlocks.d.ts

@@ -1,7 +1,7 @@
-import { Instance } from 'mobx-state-tree';
 import { BlockSet } from './blockTypes';
-import { Region } from './types';
+import type { Region } from './types';
 import type { Region as RegionModel } from './types/mst';
+import type { Instance } from 'mobx-state-tree';
 export interface Base1DViewModel {
     offsetPx: number;
     width: number;

package/util/calculateStaticBlocks.js

@@ -10,7 +10,6 @@ function calculateStaticBlocks(model, padding = true, elision = true, extra = 0,
     const windowRightBp = (offsetPx + modelWidth) * bpPerPx;
     const blockSizePx = width;
     const blockSizeBp = Math.ceil(blockSizePx * bpPerPx);
-    // for each displayed region
     let regionBpOffset = 0;
     const blocks = new blockTypes_1.BlockSet();
     for (let regionNumber = 0; regionNumber < displayedRegions.length; regionNumber++) {
@@ -75,7 +74,6 @@ function calculateStaticBlocks(model, padding = true, elision = true, extra = 0,
                 blocks.push(new blockTypes_1.ContentBlock(blockData));
             }
             if (padding) {
-                // insert a inter-region padding block if we are crossing a displayed region
                 if (regionWidthPx >= minimumBlockWidth &&
                     blockData.isRightEndOfDisplayedRegion &&
                     regionNumber < displayedRegions.length - 1) {

package/util/color/cssColorsLevel4.js

@@ -1,5 +1,4 @@
 "use strict";
-// from https://www.w3.org/TR/css-color-4/#named-colors
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.namedColorToHex = namedColorToHex;
 exports.isNamedColor = isNamedColor;

package/util/color/index.d.ts

@@ -1,23 +1,4 @@
-/**
- * Algorithmically pick a contrasting text color that will
- * be visible on top of the given background color. Either
- * black or white.
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- *  hsl(), hsla(), or named color
- * @returns 'black' or 'white'
- */
 export declare function contrastingTextColor(color: string): string;
-/**
- * Darken or lighten a color, depending on its luminance.
- * Light colors are darkened, dark colors are lightened.
- * Uses MUI's `emphasize`, but adds support for named colors
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- * hsl(), hsla(), or named color
- * @param coefficient - multiplier in the range 0 - 1, defaults to 0.15
- * @returns A CSS color string. Hex input values are returned as rgb
- */
 export declare function emphasize(color: string, coefficient?: number): string;
 export declare function makeContrasting(foreground: string, background?: string, minContrastRatio?: number): string;
 export { isNamedColor, namedColorToHex } from './cssColorsLevel4';

package/util/color/index.js

@@ -6,44 +6,14 @@ exports.emphasize = emphasize;
 exports.makeContrasting = makeContrasting;
 const styles_1 = require("@mui/material/styles");
 const cssColorsLevel4_1 = require("./cssColorsLevel4");
-/**
- * Algorithmically pick a contrasting text color that will
- * be visible on top of the given background color. Either
- * black or white.
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- *  hsl(), hsla(), or named color
- * @returns 'black' or 'white'
- */
 function contrastingTextColor(color) {
     const luminance = getLuminance(color);
     return luminance > 0.5 ? 'black' : 'white';
 }
-/**
- * The relative brightness of any point in a color space,
- * normalized to 0 for darkest black and 1 for lightest white.
- * Uses MUI's `getLuminance`, but adds support for named colors
- *
- * Formula: https://www.w3.org/TR/WCAG20-TECHS/G17.html#G17-tests
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- *  hsl(), hsla(), or named color
- * @returns The relative brightness of the color in the range 0 - 1
- */
 function getLuminance(color) {
     const convertedColor = (0, cssColorsLevel4_1.namedColorToHex)(color);
     return (0, styles_1.getLuminance)(convertedColor || color);
 }
-/**
- * Darken or lighten a color, depending on its luminance.
- * Light colors are darkened, dark colors are lightened.
- * Uses MUI's `emphasize`, but adds support for named colors
- *
- * @param color - CSS color, i.e. one of: #nnn, #nnnnnn, rgb(), rgba(),
- * hsl(), hsla(), or named color
- * @param coefficient - multiplier in the range 0 - 1, defaults to 0.15
- * @returns A CSS color string. Hex input values are returned as rgb
- */
 function emphasize(color, coefficient = 0.15) {
     const convertedColor = (0, cssColorsLevel4_1.namedColorToHex)(color);
     return (0, styles_1.emphasize)(convertedColor || color, coefficient);

package/util/compositeMap.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// takes an array or Map or Set (anything iterable with values()) of Maps and
-// lets you query them as one Map
 class CompositeMap {
     constructor(submaps) {
         this.submaps = submaps;

package/util/dedupe.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupe = dedupe;
-// from https://github.com/seriousManual/dedupe/blob/master/LICENSE
 function dedupe(list, hasher = JSON.stringify) {
     const clone = [];
     const lookup = new Set();

package/util/formatFastaStrings.d.ts

@@ -2,18 +2,5 @@ export interface SeqChunk {
     header: string;
     seq: string;
 }
-/**
- * Returns sequence with new line every 80 characters
- * ref https://stackoverflow.com/a/51506718/2129219
- *
- * @param seqString -  string
- * @returns formatted sequence string
- */
 export declare function formatFastaLines(seqString: string): string;
-/**
- * Formats the sequences chunks into Fasta format
- *
- * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
- * @returns formatted sequence in fasta format
- */
 export declare function formatSeqFasta(chunks: SeqChunk[]): string;

package/util/formatFastaStrings.js

@@ -2,22 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatFastaLines = formatFastaLines;
 exports.formatSeqFasta = formatSeqFasta;
-/**
- * Returns sequence with new line every 80 characters
- * ref https://stackoverflow.com/a/51506718/2129219
- *
- * @param seqString -  string
- * @returns formatted sequence string
- */
 function formatFastaLines(seqString) {
     return seqString.replaceAll(/(.{1,80})/g, '$1\n').trimEnd();
 }
-/**
- * Formats the sequences chunks into Fasta format
- *
- * @param chunks - array of seq chunks of the form `{ header: string, seq: string }`
- * @returns formatted sequence in fasta format
- */
 function formatSeqFasta(chunks) {
     return chunks
         .map(chunk => `>${chunk.header}\n${formatFastaLines(chunk.seq)}`)

package/util/idMaker.d.ts

@@ -1 +1 @@
-export default function idMaker(args: any, id?: string): number;
+export default function idMaker(args: Record<string, unknown>, id?: string, len?: number): number;

package/util/idMaker.js

@@ -2,19 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = idMaker;
 const _1 = require("./");
-// generates a short "id fingerprint" from the config passed to the base
-// feature adapter by recursively enumerating props, but if config is too big
-// does not process entire config (FromConfigAdapter for example can be large)
-function idMaker(args, id = '') {
-    const keys = Object.keys(args);
-    for (const key of keys) {
-        if (id.length > 5000) {
-            break;
+function idMaker(args, id = '', len = 5000) {
+    const stack = [args];
+    while (stack.length) {
+        const obj = stack.pop();
+        for (const [key, val] of Object.entries(obj)) {
+            if (id.length > len) {
+                return (0, _1.hashCode)(id);
+            }
+            else {
+                if (typeof val === 'object' && val !== null) {
+                    stack.push(val);
+                }
+                else {
+                    id += `${key}-${val}`;
+                }
+            }
         }
-        id +=
-            typeof args[key] === 'object' && args[key]
-                ? idMaker(args[key], id)
-                : `${key}-${args[key]};`;
     }
     return (0, _1.hashCode)(id);
 }

package/util/index.d.ts

@@ -1,16 +1,13 @@
-import React from 'react';
-import PluginManager from '../PluginManager';
-import type { Buffer } from 'buffer';
-import { IAnyStateTreeNode, IStateTreeNode, Instance } from 'mobx-state-tree';
-import { IReactionPublic, IReactionOptions } from 'mobx';
-import { Feature } from './simpleFeature';
-import { AssemblyManager, Region, TypeTestedByPredicate } from './types';
+import type React from 'react';
+import type PluginManager from '../PluginManager';
+import type { BaseBlock } from './blockTypes';
+import type { Feature } from './simpleFeature';
+import type { AssemblyManager, Region, TypeTestedByPredicate } from './types';
 import type { Region as MUIRegion } from './types/mst';
-import { BaseBlock } from './blockTypes';
-import { GenericFilehandle } from 'generic-filehandle';
-import { BaseOptions } from '../data_adapters/BaseAdapter';
+import type { BaseOptions } from '../data_adapters/BaseAdapter';
+import type { GenericFilehandle } from 'generic-filehandle2';
+import type { IAnyStateTreeNode, IStateTreeNode, Instance } from 'mobx-state-tree';
 export * from './types';
-export * from './aborting';
 export * from './when';
 export * from './range';
 export * from './dedupe';
@@ -19,72 +16,15 @@ export * from './offscreenCanvasUtils';
 export declare function useDebounce<T>(value: T, delay: number): T;
 export declare function useWidthSetter(view: {
     setWidth: (arg: number) => void;
-}, padding: string): React.RefObject<HTMLDivElement>;
+}, padding: string): React.RefObject<HTMLDivElement | null>;
 export declare function useDebouncedCallback<T>(callback: (...args: T[]) => void, wait?: number): (...args: T[]) => void;
-/**
- * find the first node in the hierarchy that matches the given predicate
- */
 export declare function findParentThat(node: IAnyStateTreeNode, predicate: (thing: IAnyStateTreeNode) => boolean): IAnyStateTreeNode;
 export declare function springAnimate(fromValue: number, toValue: number, setValue: (value: number) => void, onFinish?: () => void, precision?: number, tension?: number, friction?: number, clamp?: boolean): (() => void)[];
-/**
- * find the first node in the hierarchy that matches the given 'is' typescript
- * type guard predicate
- */
 export declare function findParentThatIs<T extends (a: IAnyStateTreeNode) => boolean>(node: IAnyStateTreeNode, predicate: T): TypeTestedByPredicate<T>;
-/**
- * get the current JBrowse session model, starting at any node in the state
- * tree
- */
 export declare function getSession(node: IAnyStateTreeNode): import("./types").AbstractSessionModel;
-/**
- * get the state model of the view in the state tree that contains the given
- * node
- */
 export declare function getContainingView(node: IAnyStateTreeNode): import("./types").AbstractViewModel;
-/**
- * get the state model of the view in the state tree that contains the given
- * node
- */
 export declare function getContainingTrack(node: IAnyStateTreeNode): import("./types").AbstractTrackModel;
-/**
- * get the state model of the display in the state tree that contains the given
- * node
- */
 export declare function getContainingDisplay(node: IAnyStateTreeNode): import("./types").AbstractDisplayModel;
-/**
- * Assemble a 1-based "locString" from an interbase genomic location
- * @param region - Region
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0, end: 100 })
- * // ↳ 'chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ assemblyName: 'hg19', refName: 'chr1', start: 0, end: 100 })
- * // ↳ '{hg19}chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1' })
- * // ↳ 'chr1'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0 })
- * // ↳ 'chr1:1..'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', end: 100 })
- * // ↳ 'chr1:1..100'
- * ```
- * @example
- * ```ts
- * assembleLocString({ refName: 'chr1', start: 0, end: 1 })
- * // ↳ 'chr1:1'
- * ```
- */
 export declare function assembleLocString(region: ParsedLocString): string;
 export declare function assembleLocStringFast(region: ParsedLocString, cb?: (n: number) => string | number): string;
 export interface ParsedLocString {
@@ -95,59 +35,10 @@ export interface ParsedLocString {
     reversed?: boolean;
 }
 export declare function parseLocStringOneBased(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
-/**
- * Parse a 1-based location string into an interbase genomic location
- * @param locString - Location string
- * @param isValidRefName - Function that checks if a refName exists in the set
- * of all known refNames, or in the set of refNames for an assembly if
- * assemblyName is given
- * @example
- * ```ts
- * parseLocString('chr1:1..100', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1-100', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString(`{hg19}chr1:1..100`, isValidRefName)
- * // ↳ { assemblyName: 'hg19', refName: 'chr1', start: 0, end: 100 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1', isValidRefName)
- * // ↳ { refName: 'chr1' }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0, end: 1 }
- * ```
- * @example
- * ```ts
- * parseLocString('chr1:1..', isValidRefName)
- * // ↳ { refName: 'chr1', start: 0}
- * ```
- */
 export declare function parseLocString(locString: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): ParsedLocString;
 export declare function compareLocs(locA: ParsedLocString, locB: ParsedLocString): number;
 export declare function compareLocStrings(a: string, b: string, isValidRefName: (refName: string, assemblyName?: string) => boolean): number;
-/**
- * Ensure that a number is at least min and at most max.
- *
- * @param num -
- * @param min -
- * @param  max -
- */
 export declare function clamp(num: number, min: number, max: number): number;
-/**
- * @param bp -
- * @param region -
- * @param bpPerPx -
- */
 export declare function bpToPx(bp: number, { reversed, end, start, }: {
     start?: number;
     end?: number;
@@ -155,15 +46,7 @@ export declare function bpToPx(bp: number, { reversed, end, start, }: {
 }, bpPerPx: number): number;
 export declare function radToDeg(radians: number): number;
 export declare function degToRad(degrees: number): number;
-/**
- * @returns [x, y]
- */
 export declare function polarToCartesian(rho: number, theta: number): [number, number];
-/**
- * @param x - the x
- * @param y - the y
- * @returns [rho, theta]
- */
 export declare function cartesianToPolar(x: number, y: number): [number, number];
 interface MinimalRegion {
     start: number;
@@ -173,45 +56,15 @@ interface MinimalRegion {
 export declare function featureSpanPx(feature: Feature, region: MinimalRegion, bpPerPx: number): readonly [number, number];
 export declare function bpSpanPx(leftBp: number, rightBp: number, region: MinimalRegion, bpPerPx: number): readonly [number, number];
 export declare function iterMap<T, U>(iter: Iterable<T>, func: (arg: T) => U, sizeHint?: number): U[];
-/**
- * Returns the index of the last element in the array where predicate is true,
- * and -1 otherwise. Based on https://stackoverflow.com/a/53187807
- *
- * @param array - The source array to search in
- *
- * @param predicate - find calls predicate once for each element of the array, in
- * descending order, until it finds one where predicate returns true.
- *
- * @returns findLastIndex returns element index where predicate is true.
- * Otherwise, findLastIndex returns -1.
- */
 export declare function findLastIndex<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): number;
 export declare function findLast<T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined;
-/**
- * makes a mobx reaction with the given functions, that calls actions on the
- * model for each stage of execution, and to abort the reaction function when
- * the model is destroyed.
- *
- * Will call startedFunction(signal), successFunction(result), and
- * errorFunction(error) when the async reaction function starts, completes, and
- * errors respectively.
- *
- * @param self -
- * @param dataFunction -
- * @param asyncReactionFunction -
- * @param reactionOptions -
- * @param startedFunction -
- * @param successFunction -
- * @param errorFunction -
- */
-export declare function makeAbortableReaction<T, U, V>(self: T, dataFunction: (arg: T) => U, asyncReactionFunction: (arg: U | undefined, signal: AbortSignal, model: T, handle: IReactionPublic) => Promise<V>, reactionOptions: IReactionOptions, startedFunction: (aborter: AbortController) => void, successFunction: (arg: V) => void, errorFunction: (err: unknown) => void): void;
 export declare function renameRegionIfNeeded(refNameMap: Record<string, string> | undefined, region: Region | Instance<typeof MUIRegion>): Region & {
     originalRefName?: string;
 };
 export declare function renameRegionsIfNeeded<ARGTYPE extends {
     assemblyName?: string;
     regions?: Region[];
-    signal?: AbortSignal;
+    stopToken?: string;
     adapterConfig: Record<string, unknown>;
     sessionId: string;
     statusCallback?: (arg: string) => void;
@@ -305,12 +158,9 @@ export declare const defaultCodonTable: {
     GGG: string;
     GGT: string;
 };
-/**
- * take CodonTable above and generate larger codon table that includes all
- * permutations of upper and lower case nucleotides
- */
 export declare function generateCodonTable(table: any): Record<string, string>;
 export declare function updateStatus<U>(msg: string, cb: (arg: string) => void, fn: () => U | Promise<U>): Promise<U>;
+export declare function updateStatus2<U>(msg: string, cb: (arg: string) => void, stopToken: string | undefined, fn: () => U | Promise<U>): Promise<U>;
 export declare function hashCode(str: string): number;
 export declare function objectHash(obj: Record<string, any>): string;
 interface VirtualOffset {
@@ -375,9 +225,9 @@ export declare function getEnv(obj: any): {
 };
 export declare function localStorageGetItem(item: string): string | null | undefined;
 export declare function localStorageSetItem(str: string, item: string): void;
-export declare function max(arr: number[], init?: number): number;
-export declare function min(arr: number[], init?: number): number;
-export declare function sum(arr: number[]): number;
+export declare function max(arr: Iterable<number>, init?: number): number;
+export declare function min(arr: Iterable<number>, init?: number): number;
+export declare function sum(arr: Iterable<number>): number;
 export declare function avg(arr: number[]): number;
 export declare function groupBy<T>(array: Iterable<T>, predicate: (v: T) => string): Record<string, T[]>;
 export declare function notEmpty<T>(value: T | null | undefined): value is T;
@@ -385,13 +235,12 @@ export declare function mergeIntervals<T extends {
     start: number;
     end: number;
 }>(intervals: T[], w?: number): T[];
-interface BasicFeature {
+export interface BasicFeature {
     end: number;
     start: number;
     refName: string;
-    assemblyName?: string;
 }
-export declare function gatherOverlaps(regions: BasicFeature[], w?: number): BasicFeature[];
+export declare function gatherOverlaps<T extends BasicFeature>(regions: T[], w?: number): T[];
 export declare function stripAlpha(str: string): string;
 export declare function getStrokeProps(str: string): {
     strokeOpacity: number;
@@ -401,10 +250,15 @@ export declare function getFillProps(str: string): {
     fillOpacity: number;
     fill: string;
 };
-export declare function renderToStaticMarkup(node: React.ReactElement, createRootFn?: (elt: Element | DocumentFragment) => {
-    render: (node: React.ReactElement) => unknown;
-}): string;
-export declare function isGzip(buf: Buffer): boolean;
-export declare function fetchAndMaybeUnzip(loc: GenericFilehandle, opts?: BaseOptions): Promise<Buffer>;
-export { isFeature, default as SimpleFeature, type Feature, type SimpleFeatureSerialized, type SimpleFeatureSerializedNoId, } from './simpleFeature';
+export declare function renderToStaticMarkup(node: React.ReactElement): string;
+export declare function isGzip(buf: Uint8Array): boolean;
+export declare function fetchAndMaybeUnzip(loc: GenericFilehandle, opts?: BaseOptions): Promise<Uint8Array<ArrayBufferLike>>;
+export declare function fetchAndMaybeUnzipText(loc: GenericFilehandle, opts?: BaseOptions): Promise<string>;
+export declare function isObject(x: unknown): x is Record<string | symbol | number, unknown>;
+export declare function localStorageGetNumber(key: string, defaultVal: number): number;
+export declare function localStorageGetBoolean(key: string, defaultVal: boolean): boolean;
+export declare function testAdapter(fileName: string, regex: RegExp, adapterHint: string | undefined, expected: string): boolean;
+export { type Feature, type SimpleFeatureSerialized, type SimpleFeatureSerializedNoId, default as SimpleFeature, isFeature, } from './simpleFeature';
 export { blobToDataURL } from './blobToDataURL';
+export { makeAbortableReaction } from './makeAbortableReaction';
+export * from './aborting';