SYMBOL INDEX (346 symbols across 42 files)

FILE: b+tree.d.ts
  type EditRangeResult (line 3) | type EditRangeResult<V, R = number> = {
  type DefaultComparable (line 11) | type DefaultComparable = number | string | Date | boolean | null | undef...
  class BTree (line 106) | class BTree<K = any, V = any> implements ISortedMapF<K, V>, ISortedMap<K...

FILE: b+tree.js
  function __ (line 13) | function __() { this.constructor = d; }
  function defaultComparator (line 30) | function defaultComparator(a, b) {
  function simpleComparator (line 78) | function simpleComparator(a, b) {
  function fixMaxSize (line 85) | function fixMaxSize(maxNodeSize) {
  function BTree (line 162) | function BTree(entries, compare, maxNodeSize) {
  function asSet (line 848) | function asSet(btree) {
  function iterator (line 857) | function iterator(next) {
  function BNode (line 866) | function BNode(keys, values) {
  function BNodeInternal (line 1181) | function BNodeInternal(children, size, keys) {
  function sumChildSizes (line 1508) | function sumChildSizes(children) {
  function areOverlapping (line 1519) | function areOverlapping(aMin, aMax, bMin, bMax, cmp) {
  function check (line 1533) | function check(fact) {

FILE: b+tree.ts
  type EditRangeResult (line 9) | type EditRangeResult<V,R=number> = {value?:V, break?:R, delete?:boolean};
  type index (line 11) | type index = number;
  type DefaultComparable (line 37) | type DefaultComparable = number | string | Date | boolean | null | undef...
  function defaultComparator (line 51) | function defaultComparator(a: DefaultComparable, b: DefaultComparable): ...
  function simpleComparator (line 116) | function simpleComparator(a: any, b: any): number {
  function fixMaxSize (line 122) | function fixMaxSize(maxNodeSize?: number) {
  class BTree (line 190) | class BTree<K=any, V=any> implements ISortedMapF<K,V>, ISortedMap<K,V>
    method constructor (line 209) | public constructor(entries?: [K,V][], compare?: (a: K, b: K) => number...
    method size (line 220) | get size(): number { return this._root.size(); }
    method length (line 222) | get length(): number { return this.size; }
    method isEmpty (line 224) | get isEmpty(): boolean { return this._root.size() === 0; }
    method clear (line 227) | clear() {
    method forEach (line 241) | forEach<R=number>(callback: (v:V, k:K, tree:BTree<K,V>) => {break?:R}|...
    method forEachPair (line 261) | forEachPair<R=number>(callback: (k:K, v:V, counter:number) => {break?:...
    method get (line 272) | get(key: K, defaultValue?: V): V | undefined {
    method set (line 290) | set(key: K, value: V, overwrite?: boolean): boolean {
    method has (line 309) | has(key: K): boolean {
    method delete (line 319) | delete(key: K): boolean {
    method with (line 330) | with<V2>(key: K, value?: V2, overwrite?: boolean): BTree<K,V|V2|undefi...
    method withPairs (line 336) | withPairs<V2>(pairs: [K,V|V2][], overwrite: boolean): BTree<K,V|V2> {
    method withKeys (line 349) | withKeys(keys: K[], returnThisIfUnchanged?: boolean): BTree<K,V|undefi...
    method without (line 362) | without(key: K, returnThisIfUnchanged?: boolean): this {
    method withoutKeys (line 372) | withoutKeys(keys: K[], returnThisIfUnchanged?: boolean): this {
    method withoutRange (line 378) | withoutRange(low: K, high: K, includeHigh: boolean, returnThisIfUnchan...
    method filter (line 387) | filter(callback: (k:K,v:V,counter:number) => boolean, returnThisIfUnch...
    method mapValues (line 399) | mapValues<R>(callback: (v:V,k:K,counter:number) => R): BTree<K,R> {
    method reduce (line 422) | reduce<R>(callback: (previous:R|undefined,currentPair:[K,V],counter:nu...
    method entries (line 441) | entries(lowestKey?: K, reusedArray?: (K|V)[]): IterableIterator<[K,V]> {
    method entriesReversed (line 495) | entriesReversed(highestKey?: K, reusedArray?: (K|V)[], skipHighest?: b...
    method findPath (line 556) | private findPath(key?: K): { nodequeue: BNode<K,V>[][], nodeindex: num...
    method keys (line 580) | keys(firstKey?: K): IterableIterator<K> {
    method values (line 591) | values(firstKey?: K): IterableIterator<V> {
    method maxNodeSize (line 604) | get maxNodeSize() {
    method minKey (line 609) | minKey(): K | undefined { return this._root.minKey(); }
    method maxKey (line 612) | maxKey(): K | undefined { return this._root.maxKey(); }
    method clone (line 619) | clone(): this {
    method greedyClone (line 631) | greedyClone(force?: boolean): this {
    method toArray (line 638) | toArray(maxLength: number = 0x7FFFFFFF): [K,V][] {
    method keysArray (line 646) | keysArray() {
    method valuesArray (line 654) | valuesArray() {
    method toString (line 662) | toString() {
    method setIfNotPresent (line 669) | setIfNotPresent(key: K, value: V): boolean {
    method nextHigherPair (line 679) | nextHigherPair(key: K|undefined, reusedArray?: [K,V]): [K,V]|undefined {
    method nextHigherKey (line 690) | nextHigherKey(key: K|undefined): K|undefined {
    method nextLowerPair (line 701) | nextLowerPair(key: K|undefined, reusedArray?: [K,V]): [K,V]|undefined {
    method nextLowerKey (line 712) | nextLowerKey(key: K|undefined): K|undefined {
    method getPairOrNextLower (line 724) | getPairOrNextLower(key: K, reusedArray?: [K,V]): [K,V]|undefined {
    method getPairOrNextHigher (line 735) | getPairOrNextHigher(key: K, reusedArray?: [K,V]): [K,V]|undefined {
    method changeIfPresent (line 742) | changeIfPresent(key: K, value: V): boolean {
    method getRange (line 758) | getRange(low: K, high: K, includeHigh?: boolean, maxLength: number = 0...
    method setPairs (line 776) | setPairs(pairs: [K,V][], overwrite?: boolean): number {
    method forRange (line 803) | forRange<R=number>(low: K, high: K, includeHigh: boolean, onFound?: (k...
    method editRange (line 837) | editRange<R=V>(low: K, high: K, includeHigh: boolean, onFound: (k:K,v:...
    method editAll (line 859) | editAll<R=V>(onFound: (k:K,v:V,counter:number) => EditRangeResult<V,R>...
    method deleteRange (line 871) | deleteRange(low: K, high: K, includeHigh: boolean): number {
    method deleteKeys (line 876) | deleteKeys(keys: K[]): number {
    method height (line 885) | get height(): number {
    method freeze (line 901) | freeze() {
    method unfreeze (line 911) | unfreeze() {
    method isFrozen (line 922) | get isFrozen() {
    method checkValid (line 931) | checkValid(checkOrdering = false) {
  function asSet (line 944) | function asSet<K,V>(btree: BTree<K,V>): undefined extends V ? ISortedSet...
  function iterator (line 955) | function iterator<T>(next: () => IteratorResult<T> = (() => ({ done:true...
  class BNode (line 964) | class BNode<K,V> {
    method isLeaf (line 973) | get isLeaf() { return (this as any).children === undefined; }
    method constructor (line 975) | constructor(keys: K[] = [], values?: V[]) {
    method size (line 981) | size(): number {
    method maxKey (line 988) | maxKey() {
    method indexOf (line 994) | indexOf(key: K, failXor: number, cmp: (a:K, b:K) => number): index {
    method minKey (line 1065) | minKey(): K | undefined {
    method minPair (line 1069) | minPair(reusedArray: [K,V]): [K,V] | undefined {
    method maxPair (line 1077) | maxPair(reusedArray: [K,V]): [K,V] | undefined {
    method clone (line 1086) | clone(): BNode<K,V> {
    method greedyClone (line 1091) | greedyClone(force?: boolean): BNode<K,V> {
    method get (line 1095) | get(key: K, defaultValue: V|undefined, tree: BTree<K,V>): V|undefined {
    method getPairOrNextLower (line 1100) | getPairOrNextLower(key: K, compare: (a: K, b: K) => number, inclusive:...
    method getPairOrNextHigher (line 1111) | getPairOrNextHigher(key: K, compare: (a: K, b: K) => number, inclusive...
    method checkValid (line 1123) | checkValid(depth: number, tree: BTree<K,V>, baseIndex: number, checkOr...
    method set (line 1146) | set(key: K, value: V, overwrite: boolean|undefined, tree: BTree<K,V>):...
    method reifyValues (line 1176) | reifyValues() {
    method insertInLeaf (line 1182) | insertInLeaf(i: index, key: K, value: V, tree: BTree<K,V>) {
    method takeFromRight (line 1197) | takeFromRight(rhs: BNode<K,V>) {
    method takeFromLeft (line 1212) | takeFromLeft(lhs: BNode<K,V>) {
    method splitOffRightSide (line 1227) | splitOffRightSide(): BNode<K,V> {
    method forRange (line 1237) | forRange<R>(low: K, high: K, includeHigh: boolean|undefined, editMode:...
    method mergeSibling (line 1284) | mergeSibling(rhs: BNode<K,V>, _: number) {
  class BNodeInternal (line 1297) | class BNodeInternal<K,V> extends BNode<K,V> {
    method constructor (line 1308) | constructor(children: BNode<K,V>[], size: number, keys?: K[]) {
    method clone (line 1319) | clone(): BNode<K,V> {
    method size (line 1326) | size(): number {
    method greedyClone (line 1330) | greedyClone(force?: boolean): BNode<K,V> {
    method minKey (line 1339) | minKey() {
    method minPair (line 1343) | minPair(reusedArray: [K,V]): [K,V] | undefined {
    method maxPair (line 1347) | maxPair(reusedArray: [K,V]): [K,V] | undefined {
    method get (line 1351) | get(key: K, defaultValue: V|undefined, tree: BTree<K,V>): V|undefined {
    method getPairOrNextLower (line 1356) | getPairOrNextLower(key: K, compare: (a: K, b: K) => number, inclusive:...
    method getPairOrNextHigher (line 1367) | getPairOrNextHigher(key: K, compare: (a: K, b: K) => number, inclusive...
    method checkValid (line 1378) | checkValid(depth: number, tree: BTree<K,V>, baseIndex: number, checkOr...
    method set (line 1419) | set(key: K, value: V, overwrite: boolean|undefined, tree: BTree<K,V>):...
    method insert (line 1473) | insert(i: index, child: BNode<K,V>) {
    method splitOffRightSide (line 1483) | splitOffRightSide() {
    method splitOffLeftSide (line 1498) | splitOffLeftSide() {
    method takeFromRight (line 1509) | takeFromRight(rhs: BNode<K,V>) {
    method takeFromLeft (line 1522) | takeFromLeft(lhs: BNode<K,V>) {
    method forRange (line 1541) | forRange<R>(low: K, high: K, includeHigh: boolean|undefined, editMode:...
    method tryMerge (line 1596) | tryMerge(i: index, maxSize: number): boolean {
    method mergeSibling (line 1617) | mergeSibling(rhs: BNode<K,V>, maxNodeSize: number) {
  function sumChildSizes (line 1658) | function sumChildSizes<K,V>(children: BNode<K,V>[]): number {
  function areOverlapping (line 1669) | function areOverlapping<K,V>(
  function check (line 1684) | function check(fact: boolean, ...args: any[]) {

FILE: benchmarks.ts
  class Timer (line 18) | class Timer {
    method ms (line 20) | ms() { return ((perfNow() - this.start) * 100 | 0) / 100; }
    method restart (line 21) | restart() { var ms = this.ms(); this.start += ms; return ms; }
  function fillBTreeOfSize (line 637) | function fillBTreeOfSize(size: number, first = 0, spacing?: number, valu...
  type TwoTreeBenchmark (line 644) | type TwoTreeBenchmark = (baseTitle: string, tree1: BTreeEx<number, numbe...
  function testNonOverlappingRanges (line 646) | function testNonOverlappingRanges(
  function testMaybeOverlappingRanges (line 653) | function testMaybeOverlappingRanges(
  function test50PercentOverlappingRanges (line 670) | function test50PercentOverlappingRanges(
  function testCompleteOverlap (line 684) | function testCompleteOverlap(
  function testPercentOverlap (line 699) | function testPercentOverlap(
  function testPartialMiddleOverlap (line 713) | function testPartialMiddleOverlap(
  function testRandomOverlaps (line 728) | function testRandomOverlaps(
  function testLargeSparseOverlap (line 759) | function testLargeSparseOverlap(
  function intersectBySorting (line 792) | function intersectBySorting(
  function subtractBySorting (line 819) | function subtractBySorting(
  function perfNow (line 846) | function perfNow(): number {
  function randInt (line 850) | function randInt(max: number) { return Math.random() * max | 0; }
  function swap (line 852) | function swap(keys: any[], i: number, j: number) {
  function makeArray (line 865) | function makeArray(size: number, randomOrder: boolean, lowest = 0, spaci...
  function measure (line 878) | function measure<T=void>(

FILE: extended/bulkLoad.js
  function bulkLoad (line 37) | function bulkLoad(keys, values, maxNodeSize, compare, loadFactor) {
  function bulkLoadRoot (line 50) | function bulkLoadRoot(keys, values, maxNodeSize, compare, loadFactor) {

FILE: extended/bulkLoad.ts
  function bulkLoad (line 16) | function bulkLoad<K, V>(
  function bulkLoadRoot (line 34) | function bulkLoadRoot<K, V>(

FILE: extended/decompose.js
  function decompose (line 19) | function decompose(left, right, combineFn, ignoreRight) {
  function buildFromDecomposition (line 314) | function buildFromDecomposition(constructor, branchingFactor, decomposed...
  function processSide (line 370) | function processSide(heights, nodes, start, end, step, context) {
  function splitUpwardsAndInsert (line 456) | function splitUpwardsAndInsert(context, insertionDepth, subtree) {
  function splitUpwardsAndInsertEntries (line 516) | function splitUpwardsAndInsertEntries(context, insertionDepth, entryCont...
  function ensureNotShared (line 540) | function ensureNotShared(context, isSharedFrontierDepth, depthToInclusiv...
  function updateSizeAndMax (line 562) | function updateSizeAndMax(context, unflushedSizes, isSharedFrontierDepth...
  function updateFrontier (line 587) | function updateFrontier(context, depthLastValid) {
  function findSplitCascadeEndDepth (line 608) | function findSplitCascadeEndDepth(context, insertionDepth, insertionCoun...
  function insertNoCount (line 628) | function insertNoCount(parent, index, child) {
  function getLeftmostIndex (line 633) | function getLeftmostIndex() {
  function getRightmostIndex (line 636) | function getRightmostIndex(node) {
  function getRightInsertionIndex (line 639) | function getRightInsertionIndex(node) {
  function splitOffRightSide (line 642) | function splitOffRightSide(node) {
  function splitOffLeftSide (line 645) | function splitOffLeftSide(node) {
  function balanceLeavesRight (line 648) | function balanceLeavesRight(parent, underfilled, toTake) {
  function balanceLeavesLeft (line 658) | function balanceLeavesLeft(parent, underfilled, toTake) {
  function updateRightMax (line 666) | function updateRightMax(node, maxBelow) {
  function mergeRightEntries (line 669) | function mergeRightEntries(leaf, entries) {
  function mergeLeftEntries (line 673) | function mergeLeftEntries(leaf, entries) {

FILE: extended/decompose.ts
  type DecomposeResult (line 11) | type DecomposeResult<K, V> = { heights: number[], nodes: BNode<K, V>[], ...
  type DecomposePayload (line 16) | type DecomposePayload = { disqualified: boolean };
  function decompose (line 31) | function decompose<K, V>(
  function buildFromDecomposition (line 397) | function buildFromDecomposition<TBTree extends BTree<K, V>, K, V>(
  function processSide (line 477) | function processSide<K, V>(
  function splitUpwardsAndInsert (line 582) | function splitUpwardsAndInsert<K, V>(
  function splitUpwardsAndInsertEntries (line 648) | function splitUpwardsAndInsertEntries<K, V>(
  function ensureNotShared (line 680) | function ensureNotShared<K, V>(
  function updateSizeAndMax (line 707) | function updateSizeAndMax<K, V>(
  function updateFrontier (line 736) | function updateFrontier<K, V>(context: SideContext<K, V>, depthLastValid...
  function findSplitCascadeEndDepth (line 757) | function findSplitCascadeEndDepth<K, V>(context: SideContext<K, V>, inse...
  function insertNoCount (line 777) | function insertNoCount<K, V>(
  type SideContext (line 786) | type SideContext<K, V> = {
  function getLeftmostIndex (line 799) | function getLeftmostIndex<K, V>(): number {
  function getRightmostIndex (line 803) | function getRightmostIndex<K, V>(node: BNodeInternal<K, V>): number {
  function getRightInsertionIndex (line 807) | function getRightInsertionIndex<K, V>(node: BNodeInternal<K, V>): number {
  function splitOffRightSide (line 811) | function splitOffRightSide<K, V>(node: BNodeInternal<K, V>): BNodeIntern...
  function splitOffLeftSide (line 815) | function splitOffLeftSide<K, V>(node: BNodeInternal<K, V>): BNodeInterna...
  function balanceLeavesRight (line 819) | function balanceLeavesRight<K,V>(parent: BNodeInternal<K,V>, underfilled...
  function balanceLeavesLeft (line 830) | function balanceLeavesLeft<K,V>(parent: BNodeInternal<K,V>, underfilled:...
  function updateRightMax (line 839) | function updateRightMax<K, V>(node: BNodeInternal<K, V>, maxBelow: K): v...
  function mergeRightEntries (line 843) | function mergeRightEntries<K, V>(leaf: BNode<K, V>, entries: BNode<K, V>...
  function mergeLeftEntries (line 848) | function mergeLeftEntries<K, V>(leaf: BNode<K, V>, entries: BNode<K, V>)...

FILE: extended/diffAgainst.js
  function diffAgainst (line 19) | function diffAgainst(_treeA, _treeB, onlyA, onlyB, different) {
  function finishCursorWalk (line 134) | function finishCursorWalk(cursor, cursorFinished, compareKeys, callback) {
  function stepToEnd (line 148) | function stepToEnd(cursor, callback) {
  function makeDiffCursor (line 162) | function makeDiffCursor(internal) {
  function stepDiffCursor (line 176) | function stepDiffCursor(cursor, stepToNode) {
  function compareDiffCursors (line 238) | function compareDiffCursors(cursorA, cursorB, compareKeys) {

FILE: extended/diffAgainst.ts
  function diffAgainst (line 20) | function diffAgainst<K, V, R>(
  function finishCursorWalk (line 140) | function finishCursorWalk<K, V, R>(
  function stepToEnd (line 159) | function stepToEnd<K, V, R>(
  function makeDiffCursor (line 177) | function makeDiffCursor<K, V>(
  function stepDiffCursor (line 194) | function stepDiffCursor<K, V>(cursor: DiffCursor<K, V>, stepToNode?: boo...
  function compareDiffCursors (line 254) | function compareDiffCursors<K, V>(
  type DiffCursor (line 290) | type DiffCursor<K, V> = {

FILE: extended/forEachKeyInBoth.js
  function forEachKeyInBoth (line 20) | function forEachKeyInBoth(treeA, treeB, callback) {

FILE: extended/forEachKeyInBoth.ts
  function forEachKeyInBoth (line 20) | function forEachKeyInBoth<K, V, R = void>(

FILE: extended/forEachKeyNotIn.js
  function forEachKeyNotIn (line 19) | function forEachKeyNotIn(includeTree, excludeTree, callback) {

FILE: extended/forEachKeyNotIn.ts
  function forEachKeyNotIn (line 19) | function forEachKeyNotIn<K, V, R = void>(

FILE: extended/index.d.ts
  class BTreeEx (line 9) | class BTreeEx<K = any, V = any> extends BTree<K, V> {
  type BTreeEx (line 121) | interface BTreeEx<K = any, V = any> {

FILE: extended/index.js
  function __ (line 13) | function __() { this.constructor = d; }
  function BTreeEx (line 58) | function BTreeEx() {

FILE: extended/index.ts
  class BTreeEx (line 18) | class BTreeEx<K = any, V = any> extends BTree<K, V> {
    method bulkLoad (line 30) | static bulkLoad<K, V>(
    method clone (line 45) | clone(): this {
    method greedyClone (line 55) | greedyClone(force?: boolean): this {
    method diffAgainst (line 77) | diffAgainst<R>(
    method forEachKeyInBoth (line 99) | forEachKeyInBoth<R = void>(
    method forEachKeyNotIn (line 119) | forEachKeyNotIn<R = void>(
    method intersect (line 139) | intersect(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, righ...
    method union (line 155) | union(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, rightVal...
    method subtract (line 172) | subtract(other: BTreeEx<K, V>): BTreeEx<K, V> {
  type BTreeEx (line 177) | interface BTreeEx<K = any, V = any> {
    method bulkLoad (line 30) | static bulkLoad<K, V>(
    method clone (line 45) | clone(): this {
    method greedyClone (line 55) | greedyClone(force?: boolean): this {
    method diffAgainst (line 77) | diffAgainst<R>(
    method forEachKeyInBoth (line 99) | forEachKeyInBoth<R = void>(
    method forEachKeyNotIn (line 119) | forEachKeyNotIn<R = void>(
    method intersect (line 139) | intersect(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, righ...
    method union (line 155) | union(other: BTreeEx<K, V>, combineFn: (key: K, leftValue: V, rightVal...
    method subtract (line 172) | subtract(other: BTreeEx<K, V>): BTreeEx<K, V> {

FILE: extended/intersect.js
  function intersect (line 23) | function intersect(treeA, treeB, combineFn) {

FILE: extended/intersect.ts
  function intersect (line 20) | function intersect<TBTree extends BTree<K, V>, K, V>(

FILE: extended/parallelWalk.js
  function moveForwardOne (line 10) | function moveForwardOne(cur, other) {
  function createCursor (line 28) | function createCursor(tree, makePayload, onEnterLeaf, onMoveInLeaf, onEx...
  function getKey (line 57) | function getKey(c) {
  function moveTo (line 67) | function moveTo(cur, other, targetKey, isInclusive, startedEqual) {
  function noop (line 187) | function noop() { }

FILE: extended/parallelWalk.ts
  type Cursor (line 8) | interface Cursor<K, V, TPayload> {
  function moveForwardOne (line 28) | function moveForwardOne<K, V, TP>(
  function createCursor (line 50) | function createCursor<K, V, TP>(
  function getKey (line 79) | function getKey<K, V, TP>(c: Cursor<K, V, TP>): K {
  function moveTo (line 89) | function moveTo<K, V, TP>(
  function noop (line 221) | function noop(): void { }

FILE: extended/shared.js
  function makeLeavesFrom (line 17) | function makeLeavesFrom(keys, values, maxNodeSize, loadFactor, onLeafCre...
  function checkCanDoSetOperation (line 56) | function checkCanDoSetOperation(treeA, treeB, supportsDifferentBranching...

FILE: extended/shared.ts
  type BTreeWithInternals (line 7) | type BTreeWithInternals<K, V, TBTree extends BTree<K, V> = BTree<K, V>> = {
  function makeLeavesFrom (line 25) | function makeLeavesFrom<K, V>(
  function checkCanDoSetOperation (line 74) | function checkCanDoSetOperation<K, V>(treeA: BTreeWithInternals<K, V>, t...
  type BTreeConstructor (line 88) | type BTreeConstructor<TBTree extends BTree<K, V>, K, V> = new (entries?:...

FILE: extended/subtract.js
  function subtract (line 19) | function subtract(targetTree, subtractTree) {

FILE: extended/subtract.ts
  function subtract (line 19) | function subtract<TBTree extends BTree<K, V>, K, V>(

FILE: extended/union.js
  function union (line 19) | function union(treeA, treeB, combineFn) {

FILE: extended/union.ts
  function union (line 19) | function union<TBTree extends BTree<K, V>, K, V>(

FILE: interfaces.d.ts
  type ISetSource (line 8) | interface ISetSource<K=any>
  type IMapSource (line 19) | interface IMapSource<K=any, V=any> extends ISetSource<K>
  type ISetSink (line 45) | interface ISetSink<K=any>
  type IMapSink (line 57) | interface IMapSink<K=any, V=any>
  type ISet (line 72) | interface ISet<K=any> extends ISetSource<K>, ISetSink<K> { }
  type IMap (line 77) | interface IMap<K=any, V=any> extends IMapSource<K, V>, IMapSink<K, V> { }
  type ISortedSetSource (line 81) | interface ISortedSetSource<K=any> extends ISetSource<K>
  type ISortedMapSource (line 112) | interface ISortedMapSource<K=any, V=any> extends IMapSource<K, V>, ISort...
  type ISortedSet (line 162) | interface ISortedSet<K=any> extends ISortedSetSource<K>, ISetSink<K> { }
  type ISortedMap (line 166) | interface ISortedMap<K=any, V=any> extends IMap<K,V>, ISortedMapSource<K...
  type ISetF (line 208) | interface ISetF<K=any> extends ISetSource<K> {
  type IMapF (line 240) | interface IMapF<K=any, V=any> extends IMapSource<K, V>, ISetF<K> {
  type ISortedSetF (line 274) | interface ISortedSetF<K=any> extends ISetF<K>, ISortedSetSource<K>
  type ISortedMapF (line 280) | interface ISortedMapF<K=any,V=any> extends ISortedSetF<K>, IMapF<K,V>, I...
  type ISortedMapConstructor (line 302) | interface ISortedMapConstructor<K,V> {
  type ISortedMapFConstructor (line 305) | interface ISortedMapFConstructor<K,V> {

FILE: scripts/minify.js
  function extendedTargets (line 8) | function extendedTargets() {

FILE: scripts/size-report.js
  function discoverExtendedEntries (line 11) | function discoverExtendedEntries() {
  function fileSize (line 34) | function fileSize(relativePath) {
  function gzipSize (line 45) | function gzipSize(relativePath) {
  function formatBytes (line 57) | function formatBytes(bytes) {
  function pad (line 65) | function pad(str, length) {

FILE: sorted-array.d.ts
  class SortedArray (line 3) | class SortedArray<K = any, V = any> implements IMap<K, V> {

FILE: sorted-array.js
  function SortedArray (line 5) | function SortedArray(entries, compare) {

FILE: sorted-array.ts
  class SortedArray (line 4) | class SortedArray<K=any, V=any> implements IMap<K,V>
    method constructor (line 9) | public constructor(entries?: [K,V][], compare?: (a: K, b: K) => number) {
    method size (line 17) | get size() { return this.a.length; }
    method get (line 18) | get(key: K, defaultValue?: V): V | undefined {
    method set (line 22) | set(key: K, value: V, overwrite?: boolean): boolean {
    method has (line 30) | has(key: K): boolean {
    method delete (line 33) | delete(key: K): boolean {
    method clear (line 39) | clear() { this.a = []; }
    method getArray (line 40) | getArray() { return this.a; }
    method minKey (line 41) | minKey(): K | undefined { return this.a[0][0]; }
    method maxKey (line 42) | maxKey(): K | undefined { return this.a[this.a.length-1][0]; }
    method forEach (line 43) | forEach(callbackFn: (v:V, k:K, list:SortedArray<K,V>) => void) {
    method entries (line 49) | entries(): IterableIterator<[K,V]> { return this.a.values(); }
    method keys (line 50) | keys():    IterableIterator<K> { return this.a.map(pair => pair[0]).va...
    method values (line 51) | values():  IterableIterator<V> { return this.a.map(pair => pair[1]).va...
    method indexOf (line 53) | indexOf(key: K, failXor: number): number {
  method [Symbol.iterator] (line 48) | [Symbol.iterator](): IterableIterator<[K,V]> { return this.a.values(); }

FILE: test/b+tree.test.ts
  function testComparison (line 94) | function testComparison<T>(comparison: (a: T, b: T) => number, inOrder: ...
  function buildTestTree (line 220) | function buildTestTree(entryCount: number, maxNodeSize: number) {
  function expectSize (line 228) | function expectSize(tree: BTree<number, number>, size: number) {
  function insert8 (line 325) | function insert8(maxNodeSize: number) {
  function forExpector (line 334) | function forExpector(k:number, v:string, counter:number, i:number, first...
  function testBTree (line 634) | function testBTree(maxNodeSize: number)

FILE: test/bulkLoad.test.ts
  type Pair (line 7) | type Pair = [number, number];
  function sequentialPairs (line 11) | function sequentialPairs(count: number, start = 0, step = 1): Pair[] {
  function pairsFromKeys (line 21) | function pairsFromKeys(keys: number[]): Pair[] {
  function toParallelArrays (line 25) | function toParallelArrays(pairs: Pair[]): { keys: number[]; values: numb...
  function buildTreeFromPairs (line 36) | function buildTreeFromPairs(maxNodeSize: number, pairs: Pair[], loadFact...
  function expectTreeMatches (line 43) | function expectTreeMatches(tree: BTree<number, number>, expected: Pair[]) {
  function collectLeaves (line 49) | function collectLeaves(node: BNode<number, number>): BNode<number, numbe...
  function assertInternalNodeFanout (line 59) | function assertInternalNodeFanout(node: BNode<number, number>, maxNodeSi...

FILE: test/diffAgainst.test.ts
  constant FANOUTS (line 7) | const FANOUTS = [32, 10, 4] as const;
  function runDiffAgainstSuite (line 15) | function runDiffAgainstSuite(maxNodeSize: number): void {

FILE: test/intersect.test.ts
  type SharedCall (line 13) | type SharedCall = { key: number, leftValue: number, rightValue: number };

FILE: test/shared.d.ts
  type TreeNodeStats (line 6) | type TreeNodeStats = {
  type TreeEntries (line 12) | type TreeEntries = Array<[number, number]>;
  type SetOperationFuzzSettings (line 13) | type SetOperationFuzzSettings = {
  type FuzzCase (line 19) | type FuzzCase = {
  type FuzzTreeSpec (line 36) | type FuzzTreeSpec = {
  type PopulateFuzzTreesOptions (line 41) | type PopulateFuzzTreesOptions = {

FILE: test/shared.js
  function countTreeNodeStats (line 12) | function countTreeNodeStats(tree) {
  function logTreeNodeStats (line 52) | function logTreeNodeStats(prefix, stats) {
  function randInt (line 60) | function randInt(max) {
  function expectTreeEqualTo (line 64) | function expectTreeEqualTo(tree, list) {
  function addToBoth (line 69) | function addToBoth(a, b, k, v) {
  function makeArray (line 73) | function makeArray(size, randomOrder, spacing, rng) {
  function swap (line 106) | function swap(keys, i, j) {
  function buildEntriesFromMap (line 111) | function buildEntriesFromMap(entriesMap, compareFn) {
  function populateFuzzTrees (line 118) | function populateFuzzTrees(specs, _a) {
  function applyRemovalRunsToTree (line 158) | function applyRemovalRunsToTree(tree, entries, removalChance, branchingF...
  function expectTreeMatchesEntries (line 184) | function expectTreeMatchesEntries(tree, entries) {
  function validateFuzzSettings (line 193) | function validateFuzzSettings(settings) {
  function forEachFuzzCase (line 203) | function forEachFuzzCase(settings, callback) {

FILE: test/shared.ts
  type TreeNodeStats (line 10) | type TreeNodeStats = {
  type TreeEntries (line 17) | type TreeEntries = Array<[number, number]>;
  type SetOperationFuzzSettings (line 19) | type SetOperationFuzzSettings = {
  type FuzzCase (line 26) | type FuzzCase = {
  function countTreeNodeStats (line 36) | function countTreeNodeStats<K, V>(tree: BTree<K, V>): TreeNodeStats {
  function logTreeNodeStats (line 85) | function logTreeNodeStats(prefix: string, stats: BTreeEx|TreeNodeStats):...
  function randInt (line 94) | function randInt(max: number): number {
  function expectTreeEqualTo (line 98) | function expectTreeEqualTo<K, V>(tree: BTree<K, V>, list: SortedArray<K,...
  function addToBoth (line 103) | function addToBoth<K, V>(a: IMap<K, V>, b: IMap<K, V>, k: K, v: V): void {
  function makeArray (line 107) | function makeArray(
  function swap (line 146) | function swap(keys: any[], i: number, j: number) {
  function buildEntriesFromMap (line 152) | function buildEntriesFromMap(
  type FuzzTreeSpec (line 161) | type FuzzTreeSpec = {
  type PopulateFuzzTreesOptions (line 167) | type PopulateFuzzTreesOptions = {
  function populateFuzzTrees (line 175) | function populateFuzzTrees(
  function applyRemovalRunsToTree (line 220) | function applyRemovalRunsToTree(
  function expectTreeMatchesEntries (line 251) | function expectTreeMatchesEntries(tree: BTree<number, number>, entries: ...
  function validateFuzzSettings (line 260) | function validateFuzzSettings(settings: SetOperationFuzzSettings): void {
  function forEachFuzzCase (line 271) | function forEachFuzzCase(

FILE: test/subtract.test.ts
  type NotInCall (line 14) | type NotInCall = { key: number, value: number };

FILE: test/union.test.ts
  type UnionFn (line 16) | type UnionFn = (key: number, leftValue: number, rightValue: number) => n...
  type UnionExpectationOptions (line 52) | type UnionExpectationOptions = {