@jbrowse/core 2.17.0 → 2.18.0

package/util/makeAbortableReaction.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAbortableReaction = makeAbortableReaction;
+const mobx_1 = require("mobx");
+const mobx_state_tree_1 = require("mobx-state-tree");
+const aborting_1 = require("./aborting");
+const stopToken_1 = require("./stopToken");
+function makeAbortableReaction(self, dataFunction, asyncReactionFunction, reactionOptions, startedFunction, successFunction, errorFunction) {
+    let inProgress;
+    function handleError(error) {
+        if (!(0, aborting_1.isAbortException)(error)) {
+            console.error(error);
+            if ((0, mobx_state_tree_1.isAlive)(self)) {
+                errorFunction(error);
+            }
+        }
+    }
+    (0, mobx_state_tree_1.addDisposer)(self, (0, mobx_1.reaction)(() => {
+        try {
+            return dataFunction(self);
+        }
+        catch (e) {
+            handleError(e);
+            return undefined;
+        }
+    }, async (data, mobxReactionHandle) => {
+        if (inProgress) {
+            (0, stopToken_1.stopStopToken)(inProgress);
+        }
+        if (!(0, mobx_state_tree_1.isAlive)(self)) {
+            return;
+        }
+        inProgress = (0, stopToken_1.createStopToken)();
+        startedFunction(inProgress);
+        try {
+            const result = await asyncReactionFunction(data, inProgress, self, mobxReactionHandle);
+            if ((0, mobx_state_tree_1.isAlive)(self)) {
+                successFunction(result);
+            }
+        }
+        catch (e) {
+            handleError(e);
+        }
+    }, reactionOptions));
+    (0, mobx_state_tree_1.addDisposer)(self, () => {
+        if (inProgress) {
+            (0, stopToken_1.stopStopToken)(inProgress);
+        }
+    });
+}

package/util/map-obj.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = map;
-// adapted from map-obj (MIT), with modifications to pass the "whole object"
-// from an array of objects into itself
 const isObject = (value) => typeof value === 'object' && value !== null;
-// Customized for this use-case
 const isObjectCustom = (value) => isObject(value) &&
     !(value instanceof RegExp) &&
     !(value instanceof Error) &&
     !(value instanceof Date) &&
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     !(globalThis.Blob && value instanceof globalThis.Blob);
 function map(object, mapper, isSeen = new WeakSet()) {
     if (isSeen.has(object)) {

package/util/mst-reflection.d.ts

@@ -1,24 +1,11 @@
-import { IAnyType, IModelReflectionPropertiesData, IAnyComplexType, ISimpleType, UnionStringArray } from 'mobx-state-tree';
+import type { IAnyComplexType, IAnyType, IModelReflectionPropertiesData, ISimpleType, UnionStringArray } from 'mobx-state-tree';
 export interface ILiteralType<T> extends ISimpleType<T> {
     value: T;
 }
-/**
- * get the inner type of an MST optional, array, or late type object
- */
 export declare function getSubType(type: IAnyType): IAnyType;
-/**
- * get the array of the subtypes in a union
- */
 export declare function getUnionSubTypes(unionType: IAnyType): IAnyType[];
-/**
- * get the type of one of the properties of the given MST model type
- */
 export declare function getPropertyType(type: IModelReflectionPropertiesData, propertyName: string): IAnyType;
-/**
- * get the base type from inside an MST optional type
- */
 export declare function getDefaultValue(type: IAnyType): any;
 export type IEnumerationType<T extends string> = ISimpleType<UnionStringArray<T[]>>;
-/** get the string values of an MST enumeration type */
 export declare function getEnumerationValues(type: IAnyComplexType): string[];
 export declare function resolveLateType(maybeLate: IAnyType): any;

package/util/mst-reflection.js

@@ -7,82 +7,55 @@ exports.getDefaultValue = getDefaultValue;
 exports.getEnumerationValues = getEnumerationValues;
 exports.resolveLateType = resolveLateType;
 const mobx_state_tree_1 = require("mobx-state-tree");
-/**
- * get the inner type of an MST optional, array, or late type object
- */
 function getSubType(type) {
     let t;
     if ((0, mobx_state_tree_1.isOptionalType)(type)) {
-        // @ts-expect-error
         t = type._subtype || type.type;
     }
     else if ((0, mobx_state_tree_1.isArrayType)(type) || (0, mobx_state_tree_1.isMapType)(type)) {
-        // @ts-expect-error
         t = type._subtype || type._subType || type.subType;
-        // @ts-expect-error
     }
     else if (typeof type.getSubType === 'function') {
-        // @ts-expect-error
         return type.getSubType();
     }
     else {
         throw new TypeError('unsupported mst type');
     }
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!t) {
         throw new Error('failed to get subtype');
     }
     return t;
 }
-/**
- * get the array of the subtypes in a union
- */
 function getUnionSubTypes(unionType) {
     if (!(0, mobx_state_tree_1.isUnionType)(unionType)) {
         throw new TypeError('not an MST union type');
     }
-    const t = 
-    // @ts-expect-error
-    unionType._types ||
-        // @ts-expect-error
+    const t = unionType._types ||
         unionType.types ||
-        // @ts-expect-error
         getSubType(unionType)._types ||
-        // @ts-expect-error
         getSubType(unionType).types;
     if (!t) {
-        // debugger
         throw new Error('failed to extract subtypes from mst union');
     }
     return t;
 }
-/**
- * get the type of one of the properties of the given MST model type
- */
 function getPropertyType(type, propertyName) {
     return type.properties[propertyName];
 }
-/**
- * get the base type from inside an MST optional type
- */
 function getDefaultValue(type) {
     if (!(0, mobx_state_tree_1.isOptionalType)(type)) {
         throw new TypeError('type must be an optional type');
     }
-    // @ts-expect-error
     return type._defaultValue || type.defaultValue;
 }
-/** get the string values of an MST enumeration type */
 function getEnumerationValues(type) {
     const subtypes = getUnionSubTypes(type);
-    // the subtypes should all be literals with a value member
     return subtypes.map(t => t.value);
 }
 function resolveLateType(maybeLate) {
     if (!(0, mobx_state_tree_1.isUnionType)(maybeLate) &&
         !(0, mobx_state_tree_1.isArrayType)(maybeLate) &&
         (0, mobx_state_tree_1.isLateType)(maybeLate)) {
-        // @ts-expect-error
         return maybeLate.getSubType();
     }
     return maybeLate;

package/util/nanoid.js

@@ -1,42 +1,18 @@
 "use strict";
-// This file replaces `index.js` in bundlers like webpack or Rollup,
-// according to `browser` config in `package.json`.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nanoid = exports.customAlphabet = exports.customRandom = exports.random = exports.urlAlphabet = void 0;
-// This alphabet uses `A-Za-z0-9_-` symbols.
-// The order of characters is optimized for better gzip and brotli compression.
-// Same as in non-secure/index.js
 exports.urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
 const random = bytes => crypto.getRandomValues(new Uint8Array(bytes));
 exports.random = random;
 const customRandom = (alphabet, defaultSize, getRandom) => {
-    // First, a bitmask is necessary to generate the ID. The bitmask makes bytes
-    // values closer to the alphabet size. The bitmask calculates the closest
-    // `2^31 - 1` number, which exceeds the alphabet size.
-    // For example, the bitmask for the alphabet size 30 is 31 (00011111).
-    // `Math.clz32` is not used, because it is not available in browsers.
     const mask = (2 << (Math.log(alphabet.length - 1) / Math.LN2)) - 1;
-    // Though, the bitmask solution is not perfect since the bytes exceeding
-    // the alphabet size are refused. Therefore, to reliably generate the ID,
-    // the random bytes redundancy has to be satisfied.
-    // Note: every hardware random generator call is performance expensive,
-    // because the system call for entropy collection takes a lot of time.
-    // So, to avoid additional system calls, extra bytes are requested in advance.
-    // Next, a step determines how many random bytes to generate.
-    // The number of random bytes gets decided upon the ID size, mask,
-    // alphabet size, and magic number 1.6 (using 1.6 peaks at performance
-    // according to benchmarks).
-    // `-~f => Math.ceil(f)` if f is a float
-    // `-~i => i + 1` if i is an integer
     const step = -~((1.6 * mask * defaultSize) / alphabet.length);
     return (size = defaultSize) => {
         let id = '';
         while (true) {
             const bytes = getRandom(step);
-            // A compact alternative for `for (var i = 0; i < step; i++)`.
             let j = step;
             while (j--) {
-                // Adding `|| ''` refuses a random byte that exceeds the alphabet size.
                 id += alphabet[bytes[j] & mask] || '';
                 if (id.length === size) {
                     return id;
@@ -49,18 +25,11 @@ exports.customRandom = customRandom;
 const customAlphabet = (alphabet, size = 21) => (0, exports.customRandom)(alphabet, size, exports.random);
 exports.customAlphabet = customAlphabet;
 const nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
-    // It is incorrect to use bytes exceeding the alphabet size.
-    // The following mask reduces the random byte in the 0-255 value
-    // range to the 0-63 value range. Therefore, adding hacks, such
-    // as empty string fallback or magic numbers, is unnecessary because
-    // the bitmask trims bytes down to the alphabet size.
     byte &= 63;
     if (byte < 36) {
-        // `0-9a-z`
         id += byte.toString(36);
     }
     else if (byte < 62) {
-        // `A-Z`
         id += (byte - 26).toString(36).toUpperCase();
     }
     else if (byte > 62) {

package/util/nextTick.d.ts

@@ -0,0 +1 @@
+export default function nextTickMod(): Promise<unknown>;

package/util/nextTick.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = nextTickMod;
+function nextTickMod() {
+    return new Promise(resolve => requestAnimationFrame(resolve) || setTimeout(resolve, 1));
+}

package/util/offscreenCanvasPonyfill.d.ts

@@ -2,7 +2,6 @@ type AbstractCanvas = any;
 type AbstractImageBitmap = any;
 export declare let createCanvas: (width: number, height: number) => AbstractCanvas;
 export declare let createImageBitmap: (canvas: AbstractCanvas) => Promise<AbstractImageBitmap>;
-/** the JS class (constructor) for offscreen-generated image bitmap data */
 export declare let ImageBitmapType: unknown;
 export declare function drawImageOntoCanvasContext(imageData: any, context: CanvasRenderingContext2D): void;
 export {};

package/util/offscreenCanvasPonyfill.js

@@ -1,14 +1,12 @@
 "use strict";
-/* eslint-disable react-refresh/only-export-components */
-// This file is a ponyfill for the HTML5 OffscreenCanvas API.
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImageBitmapType = exports.createImageBitmap = exports.createCanvas = void 0;
 exports.drawImageOntoCanvasContext = drawImageOntoCanvasContext;
-const detect_node_1 = __importDefault(require("detect-node"));
 const canvas_sequencer_1 = require("canvas-sequencer");
+const detect_node_1 = __importDefault(require("detect-node"));
 function drawImageOntoCanvasContext(imageData, context) {
     if (imageData.serializedCommands) {
         const seq = new canvas_sequencer_1.CanvasSequence(imageData.serializedCommands);
@@ -24,23 +22,17 @@ const weHave = {
 };
 if (weHave.realOffscreenCanvas) {
     exports.createCanvas = (width, height) => new OffscreenCanvas(width, height);
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     exports.createImageBitmap = window.createImageBitmap || self.createImageBitmap;
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     exports.ImageBitmapType = window.ImageBitmap || self.ImageBitmap;
 }
 else if (weHave.node) {
-    // use node-canvas if we are running in node (i.e. automated tests)
     exports.createCanvas = (...args) => {
-        // @ts-expect-error
         return nodeCreateCanvas(...args);
     };
     exports.createImageBitmap = async (canvas) => {
         const dataUri = canvas.toDataURL();
-        // @ts-expect-error
         const img = new nodeImage();
         return new Promise((resolve, reject) => {
-            // need onload for jest
             img.onload = () => {
                 resolve(img);
             };

package/util/offscreenCanvasUtils.js

@@ -29,12 +29,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.renderToAbstractCanvas = renderToAbstractCanvas;
 exports.getSerializedSvg = getSerializedSvg;
 exports.ReactRendering = ReactRendering;
-/* eslint-disable react-refresh/only-export-components */
 const react_1 = __importDefault(require("react"));
 const canvas_sequencer_1 = require("canvas-sequencer");
-// locals
-const offscreenCanvasPonyfill_1 = require("./offscreenCanvasPonyfill");
 const blobToDataURL_1 = require("./blobToDataURL");
+const offscreenCanvasPonyfill_1 = require("./offscreenCanvasPonyfill");
 async function renderToAbstractCanvas(width, height, opts, cb) {
     const { exportSVG, highResolutionScaling = 1 } = opts;
     if (exportSVG) {
@@ -55,8 +53,6 @@ async function renderToAbstractCanvas(width, height, opts, cb) {
             }
             ctx.scale(s, s);
             const result = await cb(ctx);
-            // two methods needed for converting canvas to PNG, one for webworker
-            // offscreen canvas, one for main thread
             return {
                 ...result,
                 reactElement: (react_1.default.createElement("image", { width: width, height: height, xlinkHref: 'convertToBlob' in canvas
@@ -81,13 +77,10 @@ async function renderToAbstractCanvas(width, height, opts, cb) {
 }
 async function getSerializedSvg(results) {
     const { width, height, canvasRecordedData } = results;
-    // @ts-ignore needs to be ignore not expect error, produces error in build step
     const C2S = await Promise.resolve().then(() => __importStar(require('canvas2svg')));
     const ctx = new C2S.default(width, height);
     const seq = new canvas_sequencer_1.CanvasSequence(canvasRecordedData);
     seq.execute(ctx);
-    // innerHTML strips the outer <svg> element from returned data, we add
-    // our own <svg> element in the view's SVG export
     return ctx.getSvg().innerHTML;
 }
 function ReactRendering({ rendering, }) {

package/util/range.d.ts

@@ -1,28 +1,3 @@
-/**
- * fast low-level intersection of 2 coordinate ranges. assumes interbase coordinates.
- *
- * assumes `left <= right` for both ranges
- *
- * @returns array of [left, right], or [] if the ranges do not intersect. the choice of [] is because it allows destructuring array assignment without check for undefined return
- */
 export declare function intersection2(left1: number, right1: number, left2: number, right2: number): [number, number] | [];
-/**
- * Return whether 2 interbase coordinate ranges intersect.
- *
- * @param left1 -
- * @param right1 -
- * @param left2 -
- * @param right2 -
- *
- * @returns true if the two ranges intersect
- */
 export declare function doesIntersect2(left1: number, right1: number, left2: number, right2: number): boolean;
-/**
- * Return whether the first region is completely contained within the second region
- *
- * @param left1 - candidate inner region left
- * @param right1 - candidate inner region right
- * @param left2 - candidate outer region left
- * @param right2 - candidate outer region right
- */
 export declare function isContainedWithin(left1: number, right1: number, left2: number, right2: number): boolean;

package/util/range.js

@@ -3,58 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.intersection2 = intersection2;
 exports.doesIntersect2 = doesIntersect2;
 exports.isContainedWithin = isContainedWithin;
-/**
- * fast low-level intersection of 2 coordinate ranges. assumes interbase coordinates.
- *
- * assumes `left <= right` for both ranges
- *
- * @returns array of [left, right], or [] if the ranges do not intersect. the choice of [] is because it allows destructuring array assignment without check for undefined return
- */
 function intersection2(left1, right1, left2, right2) {
-    // this code is verbose because "if" statements are faster than Math.min and Math.max
     if (right1 > left2 && left1 < right2 && right2 - left2 && right1 - left1) {
         if (left1 > left2) {
             if (right1 < right2) {
-                // 1     |-------|
-                //     |------------|
                 return [left1, right1];
             }
-            // 2         |----|
-            //      |------|
             return [left1, right2];
         }
         if (right1 < right2) {
-            // 3  |-----|
-            //       |------|
             return [left2, right1];
         }
-        // 4     |------------|
-        //         |-------|
         return [left2, right2];
     }
     return [];
 }
-/**
- * Return whether 2 interbase coordinate ranges intersect.
- *
- * @param left1 -
- * @param right1 -
- * @param left2 -
- * @param right2 -
- *
- * @returns true if the two ranges intersect
- */
 function doesIntersect2(left1, right1, left2, right2) {
     return right1 > left2 && left1 < right2;
 }
-/**
- * Return whether the first region is completely contained within the second region
- *
- * @param left1 - candidate inner region left
- * @param right1 - candidate inner region right
- * @param left2 - candidate outer region left
- * @param right2 - candidate outer region right
- */
 function isContainedWithin(left1, right1, left2, right2) {
     return left2 <= left1 && right2 >= right1;
 }

package/util/rxjs.d.ts

@@ -1,7 +1,3 @@
-import { Observable, Observer } from 'rxjs';
-/**
- * Wrapper for rxjs Observable.create with improved error handling and
- * aborting support
- * @param func - observer function, could be async
- */
-export declare function ObservableCreate<T>(func: (arg: Observer<T>) => void | Promise<void>, signal?: AbortSignal): Observable<T>;
+import { Observable } from 'rxjs';
+import type { Observer } from 'rxjs';
+export declare function ObservableCreate<T>(func: (arg: Observer<T>) => void | Promise<void>, _stopToken?: string): Observable<T>;

package/util/rxjs.js

@@ -2,14 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObservableCreate = ObservableCreate;
 const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const _1 = require(".");
-/**
- * Wrapper for rxjs Observable.create with improved error handling and
- * aborting support
- * @param func - observer function, could be async
- */
-function ObservableCreate(func, signal) {
+function ObservableCreate(func, _stopToken) {
     return new rxjs_1.Observable((observer) => {
         try {
             const ret = func(observer);
@@ -22,5 +15,5 @@ function ObservableCreate(func, signal) {
         catch (error) {
             observer.error(error);
         }
-    }).pipe((0, operators_1.takeUntil)((0, _1.observeAbortSignal)(signal)));
+    });
 }

package/util/simpleFeature.d.ts

@@ -1,39 +1,17 @@
-/**
- * Abstract feature object
- */
 export interface Feature {
-    /**
-     * Get a piece of data about the feature.  All features must have
-     * 'start' and 'end', but everything else is optional.
-     */
     get(name: 'refName'): string;
     get(name: 'start' | 'end'): number;
     get(name: 'subfeatures'): Feature[] | undefined;
     get(name: string): any;
-    /**
-     * Get the unique ID of this feature.
-     */
     id(): string;
-    /**
-     * Get this feature's parent feature, or undefined if none.
-     */
     parent(): Feature | undefined;
-    /**
-     * Get an array of child features, or undefined if none.
-     */
     children(): Feature[] | undefined;
-    /**
-     * Convert to JSON
-     */
     toJSON(): SimpleFeatureSerialized;
 }
 export declare function isFeature(thing: unknown): thing is Feature;
 export interface SimpleFeatureArgs {
-    /** key-value data, must include 'start' and 'end' */
     data: Record<string, unknown>;
-    /** optional parent feature */
     parent?: Feature;
-    /** unique identifier. can also be in data.uniqueId */
     id: string | number;
 }
 export interface SimpleFeatureSerializedNoId {
@@ -49,45 +27,17 @@ export interface SimpleFeatureSerialized extends SimpleFeatureSerializedNoId {
     subfeatures?: SimpleFeatureSerializedNoId[];
     uniqueId: string;
 }
-/**
- * Simple implementation of a feature object.
- */
 export default class SimpleFeature implements Feature {
     private data;
     private subfeatures?;
     private parentHandle?;
     private uniqueId;
-    /**
-     * @param args - SimpleFeature args
-     *
-     * Note: args.data.subfeatures can be an array of these same args,
-     * which will be inflated to more instances of this class.
-     */
     constructor(args: SimpleFeatureArgs | SimpleFeatureSerialized);
-    /**
-     * Get a piece of data about the feature.  All features must have
-     * 'start' and 'end', but everything else is optional.
-     */
     get(name: string): any;
-    /**
-     * Set an item of data.
-     */
     set(name: string, val: any): void;
-    /**
-     * Get an array listing which data keys are present in this feature.
-     */
     tags(): string[];
-    /**
-     * Get the unique ID of this feature.
-     */
     id(): string;
-    /**
-     * Get this feature's parent feature, or undefined if none.
-     */
     parent(): Feature | undefined;
-    /**
-     * Get an array of child features, or undefined if none.
-     */
     children(): Feature[] | undefined;
     toJSON(): SimpleFeatureSerialized;
     static fromJSON(json: SimpleFeatureSerialized): SimpleFeature;

package/util/simpleFeature.js

@@ -10,16 +10,7 @@ function isFeature(thing) {
 function isSimpleFeatureSerialized(args) {
     return 'uniqueId' in args && typeof args.data !== 'object';
 }
-/**
- * Simple implementation of a feature object.
- */
 class SimpleFeature {
-    /**
-     * @param args - SimpleFeature args
-     *
-     * Note: args.data.subfeatures can be an array of these same args,
-     * which will be inflated to more instances of this class.
-     */
     constructor(args) {
         var _a;
         if (isSimpleFeatureSerialized(args)) {
@@ -27,16 +18,9 @@ class SimpleFeature {
         }
         else {
             this.data = args.data;
-            // load handle from args.parent (not args.data.parent) this reason is
-            // because if args is an object, it likely isn't properly loaded with
-            // parent as a Feature reference (probably a raw parent ID or something
-            // instead)
             this.parentHandle = args.parent;
         }
-        // the feature id comes from args.id, args.data.uniqueId, or args.uniqueId
-        // due to this initialization
         const id = isSimpleFeatureSerialized(args) ? args.uniqueId : args.id;
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (id === undefined || id === null) {
             throw new Error('SimpleFeature requires a unique `id` or `data.uniqueId` attribute');
         }
@@ -57,10 +41,6 @@ class SimpleFeature {
                 : f);
         }
     }
-    /**
-     * Get a piece of data about the feature.  All features must have
-     * 'start' and 'end', but everything else is optional.
-     */
     get(name) {
         return name === 'subfeatures'
             ? this.subfeatures
@@ -68,33 +48,18 @@ class SimpleFeature {
                 ? this.parent()
                 : this.data[name];
     }
-    /**
-     * Set an item of data.
-     */
     set(name, val) {
         this.data[name] = val;
     }
-    /**
-     * Get an array listing which data keys are present in this feature.
-     */
     tags() {
         return Object.keys(this.data);
     }
-    /**
-     * Get the unique ID of this feature.
-     */
     id() {
         return this.uniqueId;
     }
-    /**
-     * Get this feature's parent feature, or undefined if none.
-     */
     parent() {
         return this.parentHandle;
     }
-    /**
-     * Get an array of child features, or undefined if none.
-     */
     children() {
         return this.get('subfeatures');
     }

package/util/stats.d.ts

@@ -1,6 +1,6 @@
-import { Observable } from 'rxjs';
-import { NoAssemblyRegion } from './types';
-import { Feature } from './simpleFeature';
+import type { Feature } from './simpleFeature';
+import type { NoAssemblyRegion } from './types';
+import type { Observable } from 'rxjs';
 export interface UnrectifiedQuantitativeStats {
     scoreMin: number;
     scoreMax: number;
@@ -15,30 +15,7 @@ export interface QuantitativeStats extends UnrectifiedQuantitativeStats {
     scoreMean: number;
     scoreStdDev: number;
 }
-/**
- * calculate standard deviation using the 'shortcut method' that accepts
- * the sum and the sum squares of the elements
- *
- * @param sum - sum(i, 1..n)
- * @param sumSquares - sum(i^2, 1..n)
- * @param n - number of elements
- * @param population - boolean: use population instead of sample correction
- * @returns - the estimated std deviation
- */
 export declare function calcStdFromSums(sum: number, sumSquares: number, n: number, population?: boolean): number;
-/**
- * @param stats - a summary stats object with scoreSum, featureCount,
- * scoreSumSquares, and basesCovered
- * @returns - a summary stats object with
- * scoreMean, scoreStdDev, and featureDensity added
- */
 export declare function rectifyStats(s: UnrectifiedQuantitativeStats): QuantitativeStats;
-/**
- * transform a list of scores to summary statistics
- *
- * @param region - object with start, end
- * @param features - array of features which are possibly summary features
- * @returns - object with scoreMax, scoreMin, scoreSum, scoreSumSquares, etc
- */
 export declare function scoresToStats(region: NoAssemblyRegion, feats: Observable<Feature>): Promise<QuantitativeStats>;
 export declare function blankStats(): QuantitativeStats;