@jbrowse/core 2.17.0 → 3.0.0

package/util/layouts/SceneGraph.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class SceneGraph {
-    /**
-     * note: all coordinates are inter-base or inter-pixel coordinates
-     */
     constructor(name, left, top, width, height, data) {
         this.name = name;
         this.left = left;
@@ -24,7 +21,6 @@ class SceneGraph {
         if (this.children.has(child.name)) {
             throw new Error(`child named "${child.name}" already exists`);
         }
-        // update the bounds to match the child
         child.parent = this;
         const { left: childLeft, right: childRight, top: childTop, bottom: childBottom, } = child.absolute;
         if (childLeft !== undefined &&
@@ -39,15 +35,6 @@ class SceneGraph {
     getSubRecord(name) {
         return this.children.get(name);
     }
-    /**
-     * if the record does not already cover the given absolute extents, extend it
-     * to cover them
-     *
-     * @param left -
-     * @param right -
-     * @param top -
-     * @param bottom -
-     */
     expand(newLeft, newRight, newTop, newBottom) {
         const { left, right, top, bottom } = this.absolute;
         if (left !== undefined && newLeft < left) {

package/util/makeAbortableReaction.d.ts

@@ -0,0 +1,2 @@
+import type { IReactionOptions, IReactionPublic } from 'mobx';
+export declare function makeAbortableReaction<T, U, V>(self: T, dataFunction: (arg: T) => U, asyncReactionFunction: (arg: U | undefined, stopToken: string, model: T, handle: IReactionPublic) => Promise<V>, reactionOptions: IReactionOptions, startedFunction: (stopToken: string) => void, successFunction: (arg: V) => void, errorFunction: (err: unknown) => void): void;

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.d.ts

@@ -1,5 +1,5 @@
 export const urlAlphabet: "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-export function random(bytes: any): Uint8Array;
+export function random(bytes: any): Uint8Array<any>;
 export function customRandom(alphabet: any, defaultSize: any, getRandom: any): (size?: any) => string;
 export function customAlphabet(alphabet: any, size?: number): (size?: any) => string;
 export function nanoid(size?: number): string;

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.d.ts

@@ -1,4 +1,3 @@
-import React from 'react';
 export type RenderReturn = Record<string, unknown> | undefined;
 type RendererRet = Promise<RenderReturn> | RenderReturn;
 export declare function renderToAbstractCanvas(width: number, height: number, opts: {
@@ -10,7 +9,7 @@ export declare function renderToAbstractCanvas(width: number, height: number, op
 }, cb: (ctx: CanvasRenderingContext2D) => RendererRet): Promise<{
     canvasRecordedData: any;
 } | {
-    reactElement: React.JSX.Element;
+    reactElement: import("react/jsx-runtime").JSX.Element;
 } | {
     imageData: any;
 }>;
@@ -24,5 +23,5 @@ export declare function ReactRendering({ rendering, }: {
         reactElement?: React.ReactNode;
         html?: string;
     };
-}): React.JSX.Element;
+}): import("react/jsx-runtime").JSX.Element;
 export {};

package/util/offscreenCanvasUtils.js

@@ -15,26 +15,32 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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 jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = 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,11 +61,9 @@ 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
+                reactElement: ((0, jsx_runtime_1.jsx)("image", { width: width, height: height, xlinkHref: 'convertToBlob' in canvas
                         ? await (0, blobToDataURL_1.blobToDataURL)(await canvas.convertToBlob({
                             type: 'image/png',
                         }))
@@ -81,15 +85,12 @@ 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, }) {
-    return react_1.default.isValidElement(rendering.reactElement) ? (rendering.reactElement) : (react_1.default.createElement("g", { dangerouslySetInnerHTML: { __html: rendering.html || '' } }));
+    return (0, react_1.isValidElement)(rendering.reactElement) ? (rendering.reactElement) : ((0, jsx_runtime_1.jsx)("g", { dangerouslySetInnerHTML: { __html: rendering.html || '' } }));
 }

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;