@gmod/bbi 1.0.30 → 1.0.33

package/dist/util.js

@@ -1,85 +1,92 @@
 "use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.groupBlocks = groupBlocks;
-exports.checkAbortSignal = checkAbortSignal;
-exports.abortBreakPoint = abortBreakPoint;
-exports.AbortError = void 0;
-
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
-
-var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
-var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
-
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortBreakPoint = exports.checkAbortSignal = exports.groupBlocks = exports.AbortError = void 0;
 /* eslint no-bitwise: ["error", { "allow": ["|"] }] */
-var AbortError = /*#__PURE__*/function (_Error) {
-  (0, _inherits2.default)(AbortError, _Error);
-
-  var _super = _createSuper(AbortError);
-
-  function AbortError(message) {
-    var _this;
-
-    (0, _classCallCheck2.default)(this, AbortError);
-    _this = _super.call(this, message);
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "code", void 0);
-    _this.code = 'ERR_ABORTED';
-    return _this;
-  }
-
-  return AbortError;
-}( /*#__PURE__*/(0, _wrapNativeSuper2.default)(Error)); // sort blocks by file offset and
-// group blocks that are within 2KB of eachother
-
-
+var AbortError = /** @class */ (function (_super) {
+    __extends(AbortError, _super);
+    function AbortError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.code = 'ERR_ABORTED';
+        return _this;
+    }
+    return AbortError;
+}(Error));
 exports.AbortError = AbortError;
-
+// sort blocks by file offset and
+// group blocks that are within 2KB of eachother
 function groupBlocks(blocks) {
-  blocks.sort(function (b0, b1) {
-    return (b0.offset | 0) - (b1.offset | 0);
-  });
-  var blockGroups = [];
-  var lastBlock;
-  var lastBlockEnd;
-
-  for (var i = 0; i < blocks.length; i += 1) {
-    if (lastBlock && blocks[i].offset - lastBlockEnd <= 2000) {
-      lastBlock.length += blocks[i].length - lastBlockEnd + blocks[i].offset;
-      lastBlock.blocks.push(blocks[i]);
-    } else {
-      blockGroups.push(lastBlock = {
-        blocks: [blocks[i]],
-        length: blocks[i].length,
-        offset: blocks[i].offset
-      });
+    blocks.sort(function (b0, b1) { return (b0.offset | 0) - (b1.offset | 0); });
+    var blockGroups = [];
+    var lastBlock;
+    var lastBlockEnd;
+    for (var i = 0; i < blocks.length; i += 1) {
+        if (lastBlock && blocks[i].offset - lastBlockEnd <= 2000) {
+            lastBlock.length += blocks[i].length - lastBlockEnd + blocks[i].offset;
+            lastBlock.blocks.push(blocks[i]);
+        }
+        else {
+            blockGroups.push((lastBlock = {
+                blocks: [blocks[i]],
+                length: blocks[i].length,
+                offset: blocks[i].offset,
+            }));
+        }
+        lastBlockEnd = lastBlock.offset + lastBlock.length;
     }
-
-    lastBlockEnd = lastBlock.offset + lastBlock.length;
-  }
-
-  return blockGroups;
+    return blockGroups;
 }
+exports.groupBlocks = groupBlocks;
 /**
  * Properly check if the given AbortSignal is aborted.
  * Per the standard, if the signal reads as aborted,
@@ -91,53 +98,40 @@ function groupBlocks(blocks) {
  * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
  * @returns nothing
  */
-
-
 function checkAbortSignal(signal) {
-  if (!signal) return;
-
-  if (signal.aborted) {
-    // console.log('bam aborted!')
-    if (typeof DOMException !== 'undefined') {
-      throw new DOMException('aborted', 'AbortError');
-    } else {
-      var e = new AbortError('aborted');
-      e.code = 'ERR_ABORTED';
-      throw e;
+    if (!signal) {
+        return;
+    }
+    if (signal.aborted) {
+        // console.log('bam aborted!')
+        if (typeof DOMException !== 'undefined') {
+            throw new DOMException('aborted', 'AbortError');
+        }
+        else {
+            var e = new AbortError('aborted');
+            e.code = 'ERR_ABORTED';
+            throw e;
+        }
     }
-  }
 }
+exports.checkAbortSignal = checkAbortSignal;
 /**
  * Skips to the next tick, then runs `checkAbortSignal`.
  * Await this to inside an otherwise synchronous loop to
  * provide a place to break when an abort signal is received.
  * @param {AbortSignal} signal
  */
-
-
-function abortBreakPoint(_x) {
-  return _abortBreakPoint.apply(this, arguments);
-}
-
-function _abortBreakPoint() {
-  _abortBreakPoint = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(signal) {
-    return _regenerator.default.wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            _context.next = 2;
-            return Promise.resolve();
-
-          case 2:
-            checkAbortSignal(signal);
-
-          case 3:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _abortBreakPoint.apply(this, arguments);
+function abortBreakPoint(signal) {
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve()];
+                case 1:
+                    _a.sent();
+                    checkAbortSignal(signal);
+                    return [2 /*return*/];
+            }
+        });
+    });
 }
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+exports.abortBreakPoint = abortBreakPoint;

package/esm/bbi.d.ts

@@ -0,0 +1,84 @@
+import { GenericFilehandle } from 'generic-filehandle';
+import { Observable } from 'rxjs';
+import { BlockView } from './blockView';
+export interface Feature {
+    start: number;
+    end: number;
+    score: number;
+    rest?: string;
+    minScore?: number;
+    maxScore?: number;
+    summary?: boolean;
+    uniqueId?: string;
+    field?: number;
+}
+interface Statistics {
+    scoreSum: number;
+    basesCovered: number;
+    scoreSumSquares: number;
+}
+interface RefInfo {
+    name: string;
+    id: number;
+    length: number;
+}
+export interface Header {
+    autoSql: string;
+    totalSummary: Statistics;
+    zoomLevels: any;
+    unzoomedIndexOffset: number;
+    unzoomedDataOffset: number;
+    definedFieldCount: number;
+    uncompressBufSize: number;
+    chromTreeOffset: number;
+    fileSize: number;
+    extHeaderOffset: number;
+    isBigEndian: boolean;
+    fileType: string;
+    refsByName: {
+        [key: string]: number;
+    };
+    refsByNumber: {
+        [key: number]: RefInfo;
+    };
+}
+export interface RequestOptions {
+    signal?: AbortSignal;
+    headers?: Record<string, string>;
+    [key: string]: unknown;
+}
+export declare abstract class BBI {
+    protected bbi: GenericFilehandle;
+    protected headerCache: any;
+    protected renameRefSeqs: (a: string) => string;
+    getHeader(opts?: RequestOptions | AbortSignal): any;
+    constructor(options?: {
+        filehandle?: GenericFilehandle;
+        path?: string;
+        url?: string;
+        renameRefSeqs?: (a: string) => string;
+    });
+    private _getHeader;
+    private _getMainHeader;
+    private _isBigEndian;
+    private _readChromTree;
+    protected getUnzoomedView(opts: RequestOptions): Promise<BlockView>;
+    protected abstract getView(scale: number, opts: RequestOptions): Promise<BlockView>;
+    /**
+     * Gets features from a BigWig file
+     *
+     * @param refName - The chromosome name
+     * @param start - The start of a region
+     * @param end - The end of a region
+     * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+     */
+    getFeatureStream(refName: string, start: number, end: number, opts?: RequestOptions & {
+        scale?: number;
+        basesPerSpan?: number;
+    }): Promise<Observable<Feature[]>>;
+    getFeatures(refName: string, start: number, end: number, opts?: RequestOptions & {
+        scale?: number;
+        basesPerSpan?: number;
+    }): Promise<Feature[]>;
+}
+export {};

package/esm/bbi.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BBI = void 0;
+const binary_parser_1 = require("@gmod/binary-parser");
+const generic_filehandle_1 = require("generic-filehandle");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
+const blockView_1 = require("./blockView");
+const BIG_WIG_MAGIC = -2003829722;
+const BIG_BED_MAGIC = -2021002517;
+/* get the compiled parsers for different sections of the bigwig file
+ *
+ * @param isBE - is big endian, typically false
+ * @return an object with compiled parsers
+ */
+function getParsers(isBE) {
+    const le = isBE ? 'big' : 'little';
+    const headerParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .int32('magic')
+        .uint16('version')
+        .uint16('numZoomLevels')
+        .uint64('chromTreeOffset')
+        .uint64('unzoomedDataOffset')
+        .uint64('unzoomedIndexOffset')
+        .uint16('fieldCount')
+        .uint16('definedFieldCount')
+        .uint64('asOffset') // autoSql offset, used in bigbed
+        .uint64('totalSummaryOffset')
+        .uint32('uncompressBufSize')
+        .uint64('extHeaderOffset') // name index offset, used in bigbed
+        .array('zoomLevels', {
+        length: 'numZoomLevels',
+        type: new binary_parser_1.Parser()
+            .uint32('reductionLevel')
+            .uint32('reserved')
+            .uint64('dataOffset')
+            .uint64('indexOffset'),
+    });
+    const totalSummaryParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint64('basesCovered')
+        .double('scoreMin')
+        .double('scoreMax')
+        .double('scoreSum')
+        .double('scoreSumSquares');
+    const chromTreeParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint32('magic')
+        .uint32('blockSize')
+        .uint32('keySize')
+        .uint32('valSize')
+        .uint64('itemCount');
+    const isLeafNode = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint8('isLeafNode')
+        .skip(1)
+        .uint16('cnt');
+    return {
+        chromTreeParser,
+        totalSummaryParser,
+        headerParser,
+        isLeafNode,
+    };
+}
+class BBI {
+    /*
+     * @param filehandle - a filehandle from generic-filehandle or implementing something similar to the node10 fs.promises API
+     * @param path - a Local file path as a string
+     * @param url - a URL string
+     * @param renameRefSeqs - an optional method to rename the internal reference sequences using a mapping function
+     */
+    constructor(options = {}) {
+        this.headerCache = new abortable_promise_cache_1.default({
+            cache: new quick_lru_1.default({ maxSize: 1 }),
+            fill: async (params, signal) => {
+                return this._getHeader({ ...params, signal });
+            },
+        });
+        const { filehandle, renameRefSeqs, path, url } = options;
+        this.renameRefSeqs = renameRefSeqs || ((s) => s);
+        if (filehandle) {
+            this.bbi = filehandle;
+        }
+        else if (url) {
+            this.bbi = new generic_filehandle_1.RemoteFile(url);
+        }
+        else if (path) {
+            this.bbi = new generic_filehandle_1.LocalFile(path);
+        }
+        else {
+            throw new Error('no file given');
+        }
+    }
+    /* fetch and parse header information from a bigwig or bigbed file
+     * @param abortSignal - abort the operation, can be null
+     * @return a Header object
+     */
+    getHeader(opts = {}) {
+        const options = 'aborted' in opts ? { signal: opts } : opts;
+        return this.headerCache.get(JSON.stringify(options), options, options.signal);
+    }
+    async _getHeader(opts) {
+        const header = await this._getMainHeader(opts);
+        const chroms = await this._readChromTree(header, opts);
+        return { ...header, ...chroms };
+    }
+    async _getMainHeader(opts, requestSize = 2000) {
+        const { buffer } = await this.bbi.read(Buffer.alloc(requestSize), 0, requestSize, 0, opts);
+        const isBigEndian = this._isBigEndian(buffer);
+        const ret = getParsers(isBigEndian);
+        const header = ret.headerParser.parse(buffer).result;
+        header.fileType = header.magic === BIG_BED_MAGIC ? 'bigbed' : 'bigwig';
+        if (header.asOffset > requestSize ||
+            header.totalSummaryOffset > requestSize) {
+            return this._getMainHeader(opts, requestSize * 2);
+        }
+        if (header.asOffset) {
+            header.autoSql = buffer
+                .subarray(header.asOffset, buffer.indexOf(0, header.asOffset))
+                .toString('utf8');
+        }
+        if (header.totalSummaryOffset > requestSize) {
+            return this._getMainHeader(opts, requestSize * 2);
+        }
+        if (header.totalSummaryOffset) {
+            const tail = buffer.subarray(header.totalSummaryOffset);
+            header.totalSummary = ret.totalSummaryParser.parse(tail).result;
+        }
+        return { ...header, isBigEndian };
+    }
+    _isBigEndian(buffer) {
+        let ret = buffer.readInt32LE(0);
+        if (ret === BIG_WIG_MAGIC || ret === BIG_BED_MAGIC) {
+            return false;
+        }
+        ret = buffer.readInt32BE(0);
+        if (ret === BIG_WIG_MAGIC || ret === BIG_BED_MAGIC) {
+            return true;
+        }
+        throw new Error('not a BigWig/BigBed file');
+    }
+    // todo: add progress if long running
+    async _readChromTree(header, opts) {
+        const isBE = header.isBigEndian;
+        const le = isBE ? 'big' : 'little';
+        const refsByNumber = [];
+        const refsByName = {};
+        const { chromTreeOffset } = header;
+        let { unzoomedDataOffset } = header;
+        while (unzoomedDataOffset % 4 !== 0) {
+            unzoomedDataOffset += 1;
+        }
+        const { buffer: data } = await this.bbi.read(Buffer.alloc(unzoomedDataOffset - chromTreeOffset), 0, unzoomedDataOffset - chromTreeOffset, chromTreeOffset, opts);
+        const p = getParsers(isBE);
+        const { keySize } = p.chromTreeParser.parse(data).result;
+        const leafNodeParser = new binary_parser_1.Parser()
+            .endianess(le)
+            .string('key', { stripNull: true, length: keySize })
+            .uint32('refId')
+            .uint32('refSize');
+        const nonleafNodeParser = new binary_parser_1.Parser()
+            .endianess(le)
+            .skip(keySize)
+            .uint64('childOffset');
+        const rootNodeOffset = 32;
+        const bptReadNode = async (currentOffset) => {
+            let offset = currentOffset;
+            if (offset >= data.length) {
+                throw new Error('reading beyond end of buffer');
+            }
+            const ret = p.isLeafNode.parse(data.subarray(offset));
+            const { isLeafNode, cnt } = ret.result;
+            offset += ret.offset;
+            if (isLeafNode) {
+                for (let n = 0; n < cnt; n += 1) {
+                    const leafRet = leafNodeParser.parse(data.subarray(offset));
+                    offset += leafRet.offset;
+                    const { key, refId, refSize } = leafRet.result;
+                    const refRec = { name: key, id: refId, length: refSize };
+                    refsByName[this.renameRefSeqs(key)] = refId;
+                    refsByNumber[refId] = refRec;
+                }
+            }
+            else {
+                // parse index node
+                const nextNodes = [];
+                for (let n = 0; n < cnt; n += 1) {
+                    const nonleafRet = nonleafNodeParser.parse(data.subarray(offset));
+                    let { childOffset } = nonleafRet.result;
+                    offset += nonleafRet.offset;
+                    childOffset -= chromTreeOffset;
+                    nextNodes.push(bptReadNode(childOffset));
+                }
+                await Promise.all(nextNodes);
+            }
+        };
+        await bptReadNode(rootNodeOffset);
+        return {
+            refsByName,
+            refsByNumber,
+        };
+    }
+    /*
+     * fetches the "unzoomed" view of the bigwig data. this is the default for bigbed
+     * @param abortSignal - a signal to optionally abort this operation
+     */
+    async getUnzoomedView(opts) {
+        const { unzoomedIndexOffset, zoomLevels, refsByName, uncompressBufSize, isBigEndian, fileType, } = await this.getHeader(opts);
+        const nzl = zoomLevels[0];
+        const cirLen = nzl ? nzl.dataOffset - unzoomedIndexOffset : 4000;
+        return new blockView_1.BlockView(this.bbi, refsByName, unzoomedIndexOffset, cirLen, isBigEndian, uncompressBufSize > 0, fileType);
+    }
+    /**
+     * Gets features from a BigWig file
+     *
+     * @param refName - The chromosome name
+     * @param start - The start of a region
+     * @param end - The end of a region
+     * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+     */
+    async getFeatureStream(refName, start, end, opts = {
+        scale: 1,
+    }) {
+        await this.getHeader(opts);
+        const chrName = this.renameRefSeqs(refName);
+        let view;
+        if (opts.basesPerSpan) {
+            view = await this.getView(1 / opts.basesPerSpan, opts);
+        }
+        else if (opts.scale) {
+            view = await this.getView(opts.scale, opts);
+        }
+        else {
+            view = await this.getView(1, opts);
+        }
+        if (!view) {
+            throw new Error('unable to get block view for data');
+        }
+        return new rxjs_1.Observable((observer) => {
+            view.readWigData(chrName, start, end, observer, opts);
+        });
+    }
+    async getFeatures(refName, start, end, opts = {
+        scale: 1,
+    }) {
+        const ob = await this.getFeatureStream(refName, start, end, opts);
+        const ret = await ob
+            .pipe((0, operators_1.reduce)((acc, curr) => acc.concat(curr)))
+            .toPromise();
+        return ret || [];
+    }
+}
+exports.BBI = BBI;

package/esm/bigbed.d.ts

@@ -0,0 +1,12 @@
+import { BBI, Feature, RequestOptions } from './bbi';
+import { BlockView } from './blockView';
+export declare function filterUndef<T>(ts: (T | undefined)[]): T[];
+export declare class BigBed extends BBI {
+    readIndicesCache: any;
+    constructor(opts?: any);
+    readIndices(opts?: AbortSignal | RequestOptions): any;
+    protected getView(scale: number, opts: RequestOptions): Promise<BlockView>;
+    private _readIndices;
+    private searchExtraIndexBlocks;
+    searchExtraIndex(name: string, opts?: RequestOptions): Promise<Feature[]>;
+}