sorted-collections 1.0.2

package/dist/index.d.ts

@@ -0,0 +1,431 @@
+/**
+ * A standard JS/TS comparator: negative if `a` sorts before `b`, positive if
+ * after, zero if equal.
+ */
+type Comparator<T> = (a: T, b: T) => number;
+interface SortedOptions<T> {
+    comparator?: Comparator<T>;
+}
+interface SortedOptionsRequired<T> {
+    comparator: Comparator<T>;
+}
+/** Types with a natural order (`<`/`>`) usable without an explicit comparator. */
+type NaturallyOrderable = number | string;
+/**
+ * Rest-tuple used in constructors so TypeScript enforces a comparator at
+ * compile time for any `T` that isn't naturally orderable, while keeping it
+ * optional for `number`/`string`.
+ */
+type ComparatorArg<T> = T extends NaturallyOrderable ? [options?: SortedOptions<T>] : [options: SortedOptionsRequired<T>];
+
+/**
+ * A list that keeps its elements in sorted order as they're inserted.
+ *
+ * A thin public wrapper around the internal {@link BucketEngine} — see there
+ * for the actual "list of lists" (sqrt-decomposition) implementation and its
+ * complexity notes.
+ *
+ * @example
+ * ```ts
+ * const scores = new SortedList<number>([42, 7, 99]);
+ * scores.add(15);
+ * [...scores]; // [7, 15, 42, 99]
+ * ```
+ */
+declare class SortedList<T> implements Iterable<T> {
+    private readonly engine;
+    /**
+     * @example
+     * ```ts
+     * new SortedList<number>(); // empty
+     * new SortedList<number>([3, 1, 2]); // [1, 2, 3]
+     * new SortedList<Person>([...], { comparator: (a, b) => a.age - b.age });
+     * ```
+     */
+    constructor(iterable?: Iterable<T>, ...options: ComparatorArg<T>);
+    /** Safe to call from subclasses/clone: both `ComparatorArg<T>` branches accept `{ comparator }`. */
+    protected comparatorArg(): ComparatorArg<T>;
+    /**
+     * O(√n) amortized.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>();
+     * scores.add(42);
+     * scores.add(7);
+     * [...scores]; // [7, 42]
+     * ```
+     */
+    add(value: T): void;
+    /**
+     * Bulk-inserts every value from `iterable`, one {@link add} at a time.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([3, 1]);
+     * scores.update([2, 5, 4]);
+     * [...scores]; // [1, 2, 3, 4, 5]
+     * ```
+     */
+    update(iterable: Iterable<T>): void;
+    /**
+     * Removes the first occurrence of `value`. Returns `false` if it wasn't present.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([1, 2, 2, 3]);
+     * scores.remove(2); // true — removes one occurrence
+     * scores.remove(99); // false — not present
+     * ```
+     */
+    remove(value: T): boolean;
+    /**
+     * Like {@link remove}, but never throws (or returns anything) if `value` isn't present.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([1, 2, 3]);
+     * scores.discard(99); // no-op, no error
+     * ```
+     */
+    discard(value: T): void;
+    /**
+     * Removes and returns the element at `index` (default: the last element).
+     * Negative indices count from the end, same as {@link at}.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([10, 20, 30]);
+     * scores.pop(); // 30 — last element
+     * scores.pop(0); // 10 — first element
+     * ```
+     */
+    pop(index?: number): T;
+    /**
+     * O(√n): walks bucket lengths to find the element at `index` (negative indices count from the end).
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([10, 20, 30]);
+     * scores.at(0); // 10
+     * scores.at(-1); // 30 — same as Array.prototype.at
+     * scores.at(99); // undefined — out of range
+     * ```
+     */
+    at(index: number): T | undefined;
+    /**
+     * The index of the first occurrence of `value`, or `-1` if absent.
+     *
+     * @example
+     * ```ts
+     * new SortedList<number>([1, 2, 2, 3]).indexOf(2); // 1
+     * new SortedList<number>([1, 2, 3]).indexOf(99); // -1
+     * ```
+     */
+    indexOf(value: T): number;
+    /**
+     * O(log n): binary search for the bucket, then binary search within it.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([1, 2, 3]);
+     * scores.has(2); // true
+     * scores.has(99); // false
+     * ```
+     */
+    has(value: T): boolean;
+    /**
+     * The leftmost index where `value` could be inserted while keeping the list sorted.
+     *
+     * @example
+     * ```ts
+     * new SortedList<number>([1, 2, 2, 2, 3]).bisectLeft(2); // 1
+     * ```
+     */
+    bisectLeft(value: T): number;
+    /**
+     * The rightmost index where `value` could be inserted while keeping the list sorted.
+     *
+     * @example
+     * ```ts
+     * new SortedList<number>([1, 2, 2, 2, 3]).bisectRight(2); // 4
+     * ```
+     */
+    bisectRight(value: T): number;
+    /**
+     * O(log n) to locate both bounds by value + O(k) to iterate the k results.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([1, 2, 3, 4, 5]);
+     * [...scores.irange(2, 4)]; // [2, 3, 4] — inclusive by default
+     * [...scores.irange(2, 4, { inclusive: [false, true] })]; // [3, 4]
+     * ```
+     */
+    irange(min?: T, max?: T, options?: {
+        inclusive?: [boolean, boolean];
+    }): IterableIterator<T>;
+    /**
+     * O(√n) to locate both positional bounds + O(k) to iterate the k results.
+     *
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([10, 20, 30, 40, 50]);
+     * [...scores.islice(1, 4)]; // [20, 30, 40] — like Array.prototype.slice
+     * ```
+     */
+    islice(start?: number, end?: number): IterableIterator<T>;
+    /**
+     * @example
+     * ```ts
+     * new SortedList<number>([1, 2, 3]).length; // 3
+     * ```
+     */
+    get length(): number;
+    /**
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([1, 2, 3]);
+     * scores.clear();
+     * scores.length; // 0
+     * ```
+     */
+    clear(): void;
+    /**
+     * An independent copy — mutating the clone never affects the original.
+     *
+     * @example
+     * ```ts
+     * const original = new SortedList<number>([1, 2, 3]);
+     * const copy = original.clone();
+     * copy.add(4);
+     * original.length; // 3
+     * copy.length; // 4
+     * ```
+     */
+    clone(): SortedList<T>;
+    /**
+     * @example
+     * ```ts
+     * const scores = new SortedList<number>([3, 1, 2]);
+     * for (const value of scores) console.log(value); // 1, 2, 3
+     * ```
+     */
+    [Symbol.iterator](): IterableIterator<T>;
+}
+
+/**
+ * Like {@link SortedList}, but rejects duplicates (compared via the
+ * comparator, not reference identity). Adds set-theory operations.
+ *
+ * Reuses `SortedList`'s bucket structure entirely: the only behavioral
+ * difference is that `add` is a no-op for values already present.
+ *
+ * @example
+ * ```ts
+ * const tags = new SortedSet<string>(['b', 'a', 'c', 'a']);
+ * [...tags]; // ['a', 'b', 'c'] — the duplicate 'a' was dropped
+ * ```
+ */
+declare class SortedSet<T> extends SortedList<T> {
+    /**
+     * O(log n) `has` check + O(√n) amortized insert if the value is new.
+     *
+     * @example
+     * ```ts
+     * const tags = new SortedSet<string>(['a']);
+     * tags.add('a'); // no-op, already present
+     * tags.length; // 1
+     * ```
+     */
+    add(value: T): void;
+    /**
+     * @example
+     * ```ts
+     * const original = new SortedSet<number>([1, 2, 3]);
+     * const copy = original.clone();
+     * copy.add(4);
+     * original.length; // 3
+     * ```
+     */
+    clone(): SortedSet<T>;
+    /**
+     * O(m log n + m) for a set of size m being merged in.
+     *
+     * @example
+     * ```ts
+     * const a = new SortedSet<number>([1, 2, 3]);
+     * const b = new SortedSet<number>([3, 4]);
+     * [...a.union(b)]; // [1, 2, 3, 4]
+     * ```
+     */
+    union(other: SortedSet<T>): SortedSet<T>;
+    /**
+     * @example
+     * ```ts
+     * const a = new SortedSet<number>([1, 2, 3]);
+     * const b = new SortedSet<number>([2, 3, 4]);
+     * [...a.intersection(b)]; // [2, 3]
+     * ```
+     */
+    intersection(other: SortedSet<T>): SortedSet<T>;
+    /**
+     * @example
+     * ```ts
+     * const a = new SortedSet<number>([1, 2, 3]);
+     * const b = new SortedSet<number>([2, 3]);
+     * [...a.difference(b)]; // [1] — in a, not in b
+     * ```
+     */
+    difference(other: SortedSet<T>): SortedSet<T>;
+    /**
+     * @example
+     * ```ts
+     * new SortedSet<number>([2, 3]).isSubsetOf(new SortedSet<number>([1, 2, 3, 4])); // true
+     * new SortedSet<number>([1, 5]).isSubsetOf(new SortedSet<number>([1, 2, 3])); // false
+     * ```
+     */
+    isSubsetOf(other: SortedSet<T>): boolean;
+}
+
+/**
+ * A dictionary ordered by key.
+ *
+ * Uses the internal {@link BucketEngine} directly (on `[K, V]` tuples, with a
+ * comparator that only looks at the key) rather than composing over
+ * `SortedList`'s public API. Two reasons: `set` needs the engine's O(log n)
+ * in-place replace-or-insert (`SortedList#bisectLeft` + `#at` would pay for a
+ * positional index it doesn't need), and `get`/`has`/`delete` use the `*By`
+ * lookup methods with a closure over the bare key — that compares the key
+ * only once per candidate (not twice, since the search side needs no
+ * `entry[0]` unwrapping) and avoids allocating a throwaway `[key, undefined]`
+ * search tuple per call.
+ *
+ * @example
+ * ```ts
+ * const byPrice = new SortedMap<number, string>([[101.5, 'order-1'], [99.75, 'order-2']]);
+ * [...byPrice.keys()]; // [99.75, 101.5]
+ * ```
+ */
+declare class SortedMap<K, V> implements Iterable<[K, V]> {
+    private readonly engine;
+    private readonly keyComparator;
+    /**
+     * @example
+     * ```ts
+     * new SortedMap<number, string>(); // empty
+     * new SortedMap<number, string>([[2, 'b'], [1, 'a']]); // ordered by key: 1, 2
+     * ```
+     */
+    constructor(entries?: Iterable<[K, V]>, ...options: ComparatorArg<K>);
+    /**
+     * O(log n) to locate + O(1) to replace in place, or O(√n) amortized to insert.
+     *
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>();
+     * byPrice.set(101.5, 'order-1');
+     * byPrice.set(101.5, 'order-1-updated'); // overwrites, doesn't grow size
+     * ```
+     */
+    set(key: K, value: V): void;
+    /**
+     * O(log n): binary search for the bucket, then binary search within it.
+     *
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[101.5, 'order-1']]);
+     * byPrice.get(101.5); // 'order-1'
+     * byPrice.get(1); // undefined
+     * ```
+     */
+    get(key: K): V | undefined;
+    /**
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[101.5, 'order-1']]);
+     * byPrice.delete(101.5); // true
+     * byPrice.delete(101.5); // false — already gone
+     * ```
+     */
+    delete(key: K): boolean;
+    /**
+     * @example
+     * ```ts
+     * new SortedMap<number, string>([[1, 'a']]).has(1); // true
+     * ```
+     */
+    has(key: K): boolean;
+    /**
+     * A snapshot `SortedSet` of the current keys — not a live view.
+     *
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[2, 'b'], [1, 'a']]);
+     * [...byPrice.keys()]; // [1, 2]
+     * ```
+     */
+    keys(): SortedSet<K>;
+    private keysGenerator;
+    /**
+     * @example
+     * ```ts
+     * [...new SortedMap<number, string>([[2, 'b'], [1, 'a']]).values()]; // ['a', 'b']
+     * ```
+     */
+    values(): IterableIterator<V>;
+    /**
+     * @example
+     * ```ts
+     * [...new SortedMap<number, string>([[2, 'b'], [1, 'a']]).entries()]; // [[1, 'a'], [2, 'b']]
+     * ```
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Iterates `[key, value]` pairs with keys in `[minKey, maxKey]`.
+     *
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[95, 'a'], [100, 'b'], [105, 'c']]);
+     * [...byPrice.irange(95, 100)]; // [[95, 'a'], [100, 'b']]
+     * ```
+     */
+    irange(minKey?: K, maxKey?: K): IterableIterator<[K, V]>;
+    /**
+     * O(√n). Entry at ordinal position `index` in key order.
+     *
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[2, 'b'], [1, 'a']]);
+     * byPrice.at(0); // [1, 'a']
+     * ```
+     */
+    at(index: number): [K, V] | undefined;
+    /**
+     * @example
+     * ```ts
+     * new SortedMap<number, string>([[1, 'a'], [2, 'b']]).size; // 2
+     * ```
+     */
+    get size(): number;
+    /**
+     * @example
+     * ```ts
+     * const byPrice = new SortedMap<number, string>([[1, 'a']]);
+     * byPrice.clear();
+     * byPrice.size; // 0
+     * ```
+     */
+    clear(): void;
+    /**
+     * @example
+     * ```ts
+     * for (const [key, value] of new SortedMap([[2, 'b'], [1, 'a']])) {
+     *   console.log(key, value); // 1 'a', then 2 'b'
+     * }
+     * ```
+     */
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+}
+
+export { type Comparator, type NaturallyOrderable, SortedList, SortedMap, type SortedOptions, type SortedOptionsRequired, SortedSet };

package/dist/index.js

@@ -0,0 +1,2 @@
+function m(i,t,e,r){let n=0,o=i;for(;n<o;){let s=n+o>>>1,a=e(t(s));(r==="left"?a>=0:a>0)?o=s:n=s+1;}return n}var h=class h{constructor(t){this.buckets=[];this.count=0;this.comparator=t;}targetBucketSize(){return Math.max(h.MIN_BUCKET_SIZE,Math.ceil(Math.sqrt(this.count)))}maybeSplit(t){let e=this.buckets[t],r=this.targetBucketSize();if(e.length>r*2){let n=e.length>>>1,o=e.splice(n);this.buckets.splice(t+1,0,o);}}maybeMerge(t){let e=this.buckets[t];if(e.length===0){this.buckets.splice(t,1);return}if(this.buckets.length<=1)return;let r=this.targetBucketSize();if(e.length<r/2){let n=t>0?t-1:t+1,[o,s]=t<n?[t,n]:[n,t],a=this.buckets[o].concat(this.buckets[s]);this.buckets.splice(o,2,a),this.maybeSplit(o);}}locateBy(t,e){let r=m(this.buckets.length,a=>{let d=this.buckets[a];return d[d.length-1]},t,e),n=Math.min(r,this.buckets.length-1),o=this.buckets[n],s=m(o.length,a=>o[a],t,e);return {bucketIndex:n,localIndex:s}}locate(t,e){return this.locateBy(r=>this.comparator(r,t),e)}locatePosition(t){if(t<0||t>=this.count)return;let e=t;for(let r=0;r<this.buckets.length;r++){let n=this.buckets[r];if(e<n.length)return {bucketIndex:r,localIndex:e};e-=n.length;}throw new Error("BucketEngine: internal invariant violated (count out of sync with buckets)")}globalIndex(t,e){let r=e;for(let n=0;n<t;n++)r+=this.buckets[n].length;return r}resolveIndex(t){return t<0?this.count+t:t}*iterateRange(t,e){for(let r=t.bucketIndex;r<this.buckets.length;r++){if(e&&r>e.bucketIndex)return;let n=this.buckets[r],o=r===t.bucketIndex?t.localIndex:0,s=e&&r===e.bucketIndex?e.localIndex:n.length;for(let a=o;a<s;a++)yield n[a];}}add(t){if(this.buckets.length===0){this.buckets.push([t]),this.count+=1;return}let{bucketIndex:e,localIndex:r}=this.locate(t,"right");this.buckets[e].splice(r,0,t),this.count+=1,this.maybeSplit(e);}set(t){if(this.buckets.length===0){this.buckets.push([t]),this.count+=1;return}let{bucketIndex:e,localIndex:r}=this.locate(t,"left"),n=this.buckets[e];if(r<n.length&&this.comparator(n[r],t)===0){n[r]=t;return}n.splice(r,0,t),this.count+=1,this.maybeSplit(e);}remove(t){return this.removeBy(e=>this.comparator(e,t))}removeBy(t){if(this.buckets.length===0)return  false;let{bucketIndex:e,localIndex:r}=this.locateBy(t,"left"),n=this.buckets[e];return r>=n.length||t(n[r])!==0?false:(n.splice(r,1),this.count-=1,this.maybeMerge(e),true)}discard(t){this.remove(t);}pop(t){if(this.count===0)throw new RangeError("SortedList#pop: list is empty");let e=t===void 0?this.count-1:this.resolveIndex(t),r=this.locatePosition(e);if(!r)throw new RangeError(`SortedList#pop: index ${t} is out of range`);let n=this.buckets[r.bucketIndex],[o]=n.splice(r.localIndex,1);return this.count-=1,this.maybeMerge(r.bucketIndex),o}at(t){let e=this.locatePosition(this.resolveIndex(t));if(e)return this.buckets[e.bucketIndex][e.localIndex]}indexOf(t){if(this.buckets.length===0)return  -1;let{bucketIndex:e,localIndex:r}=this.locate(t,"left"),n=this.buckets[e];return r>=n.length||this.comparator(n[r],t)!==0?-1:this.globalIndex(e,r)}has(t){return this.hasBy(e=>this.comparator(e,t))}hasBy(t){return this.findBy(t)!==void 0}findBy(t){if(this.buckets.length===0)return;let{bucketIndex:e,localIndex:r}=this.locateBy(t,"left"),n=this.buckets[e];return r<n.length&&t(n[r])===0?n[r]:void 0}bisectLeft(t){if(this.buckets.length===0)return 0;let{bucketIndex:e,localIndex:r}=this.locate(t,"left");return this.globalIndex(e,r)}bisectRight(t){if(this.buckets.length===0)return 0;let{bucketIndex:e,localIndex:r}=this.locate(t,"right");return this.globalIndex(e,r)}irange(t,e,r){if(this.buckets.length===0)return this.iterateRange({bucketIndex:0,localIndex:0});let[n,o]=r?.inclusive??[true,true],s=t===void 0?{bucketIndex:0,localIndex:0}:this.locate(t,n?"left":"right"),a=e===void 0?void 0:this.locate(e,o?"right":"left");return this.iterateRange(s,a)}islice(t,e){let r=Math.max(0,t===void 0?0:this.resolveIndex(t)),n=Math.min(this.count,e===void 0?this.count:this.resolveIndex(e));if(r>=n||this.count===0)return this.iterateRange({bucketIndex:0,localIndex:0},{bucketIndex:0,localIndex:0});let o=this.locatePosition(r),s=this.locatePosition(n-1);return this.iterateRange(o,{bucketIndex:s.bucketIndex,localIndex:s.localIndex+1})}get length(){return this.count}clear(){this.buckets=[],this.count=0;}[Symbol.iterator](){return this.iterateRange({bucketIndex:0,localIndex:0})}};h.MIN_BUCKET_SIZE=32;var c=h;function f(i,t){if(typeof i=="number"&&typeof t=="number")return i-t;let e=String(i),r=String(t);return e<r?-1:e>r?1:0}var u=class i{constructor(t,...e){let n=e[0]?.comparator??f;this.engine=new c(n),t&&this.update(t);}comparatorArg(){return [{comparator:this.engine.comparator}]}add(t){this.engine.add(t);}update(t){for(let e of t)this.add(e);}remove(t){return this.engine.remove(t)}discard(t){this.engine.discard(t);}pop(t){return this.engine.pop(t)}at(t){return this.engine.at(t)}indexOf(t){return this.engine.indexOf(t)}has(t){return this.engine.has(t)}bisectLeft(t){return this.engine.bisectLeft(t)}bisectRight(t){return this.engine.bisectRight(t)}irange(t,e,r){return this.engine.irange(t,e,r)}islice(t,e){return this.engine.islice(t,e)}get length(){return this.engine.length}clear(){this.engine.clear();}clone(){return new i(this,...this.comparatorArg())}[Symbol.iterator](){return this.engine[Symbol.iterator]()}};var l=class i extends u{add(t){this.has(t)||super.add(t);}clone(){return new i(this,...this.comparatorArg())}union(t){let e=this.clone();for(let r of t)e.add(r);return e}intersection(t){let e=new i([],...this.comparatorArg());for(let r of this)t.has(r)&&e.add(r);return e}difference(t){let e=new i([],...this.comparatorArg());for(let r of this)t.has(r)||e.add(r);return e}isSubsetOf(t){for(let e of this)if(!t.has(e))return  false;return  true}};function p(i,t){if(typeof i=="number"&&typeof t=="number")return i-t;let e=String(i),r=String(t);return e<r?-1:e>r?1:0}function g(i){return [{comparator:i}]}var b=class{constructor(t,...e){let r=e[0];this.keyComparator=r?.comparator??p;let n=(o,s)=>this.keyComparator(o[0],s[0]);if(this.engine=new c(n),t)for(let[o,s]of t)this.set(o,s);}set(t,e){this.engine.set([t,e]);}get(t){return this.engine.findBy(e=>this.keyComparator(e[0],t))?.[1]}delete(t){return this.engine.removeBy(e=>this.keyComparator(e[0],t))}has(t){return this.engine.hasBy(e=>this.keyComparator(e[0],t))}keys(){return new l(this.keysGenerator(),...g(this.keyComparator))}*keysGenerator(){for(let[t]of this.engine)yield t;}*values(){for(let[,t]of this.engine)yield t;}entries(){return this.engine[Symbol.iterator]()}irange(t,e){let r=t===void 0?void 0:[t,void 0],n=e===void 0?void 0:[e,void 0];return this.engine.irange(r,n)}at(t){return this.engine.at(t)}get size(){return this.engine.length}clear(){this.engine.clear();}[Symbol.iterator](){return this.engine[Symbol.iterator]()}};export{u as SortedList,b as SortedMap,l as SortedSet};//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/bucket-engine.ts","../src/sorted-list.ts","../src/sorted-set.ts","../src/sorted-map.ts"],"names":["bisectByCompare","length","getCandidate","compare","bias","lo","hi","mid","cmp","_BucketEngine","comparator","bucketIndex","bucket","target","right","neighborIndex","a","b","merged","i","clampedBucketIndex","localIndex","value","candidate","index","remaining","total","start","end","from","to","resolved","location","min","max","options","minInclusive","maxInclusive","resolvedStart","resolvedEnd","startLoc","endLoc","BucketEngine","defaultComparator","left","SortedList","_SortedList","iterable","SortedSet","_SortedSet","other","result","defaultKeyComparator","comparatorArgs","SortedMap","entries","opts","entryComparator","key","entry","minKey","maxKey"],"mappings":"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","file":"index.js","sourcesContent":["import type { Comparator } from '../types.js';\n\ntype Bias = 'left' | 'right';\n\n/**\n * Generic binary search over `length` candidates. `compare(candidate)` must\n * return the same sign a comparator would for `comparator(candidate, target)`\n * — i.e. negative if the candidate sorts before the (implicit) target.\n * Taking a closure instead of `(target, comparator)` lets callers search by\n * a bare key without constructing a throwaway full element to compare against.\n */\nfunction bisectByCompare<T>(\n  length: number,\n  getCandidate: (index: number) => T,\n  compare: (candidate: T) => number,\n  bias: Bias,\n): number {\n  let lo = 0;\n  let hi = length;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    const cmp = compare(getCandidate(mid));\n    const goLeft = bias === 'left' ? cmp >= 0 : cmp > 0;\n    if (goLeft) {\n      hi = mid;\n    } else {\n      lo = mid + 1;\n    }\n  }\n  return lo;\n}\n\ninterface BucketLocation {\n  bucketIndex: number;\n  localIndex: number;\n}\n\n/**\n * Internal \"list of lists\" (sqrt-decomposition) engine shared by `SortedList`\n * and `SortedMap` — not part of the public API.\n *\n * Buckets of roughly √n sorted elements each, the same technique used by\n * Python's `sortedcontainers`. Locating a bucket by value is a binary search\n * over bucket boundaries (O(log buckets)); locating by position walks bucket\n * lengths (O(buckets)). With bucket count kept close to √n, that's O(log n)\n * and O(√n) respectively.\n *\n * `SortedMap` uses the `*By` methods directly (with a closure that compares\n * a stored `[K, V]` entry against a bare key) instead of `SortedList`'s\n * public wrapper: going through `bisectLeft` + `at` would pay for a\n * positional index (O(√n)) it doesn't need, and comparing via a search value\n * would need a throwaway `[key, undefined]` tuple and double key-unwrapping\n * per comparison instead of one.\n */\nexport class BucketEngine<T> implements Iterable<T> {\n  private static readonly MIN_BUCKET_SIZE = 32;\n\n  private buckets: T[][] = [];\n  private count = 0;\n  readonly comparator: Comparator<T>;\n\n  constructor(comparator: Comparator<T>) {\n    this.comparator = comparator;\n  }\n\n  private targetBucketSize(): number {\n    return Math.max(BucketEngine.MIN_BUCKET_SIZE, Math.ceil(Math.sqrt(this.count)));\n  }\n\n  private maybeSplit(bucketIndex: number): void {\n    const bucket = this.buckets[bucketIndex]!;\n    const target = this.targetBucketSize();\n    if (bucket.length > target * 2) {\n      const mid = bucket.length >>> 1;\n      const right = bucket.splice(mid);\n      this.buckets.splice(bucketIndex + 1, 0, right);\n    }\n  }\n\n  private maybeMerge(bucketIndex: number): void {\n    const bucket = this.buckets[bucketIndex]!;\n    if (bucket.length === 0) {\n      this.buckets.splice(bucketIndex, 1);\n      return;\n    }\n    if (this.buckets.length <= 1) {\n      return;\n    }\n    const target = this.targetBucketSize();\n    if (bucket.length < target / 2) {\n      const neighborIndex = bucketIndex > 0 ? bucketIndex - 1 : bucketIndex + 1;\n      const [a, b] =\n        bucketIndex < neighborIndex ? [bucketIndex, neighborIndex] : [neighborIndex, bucketIndex];\n      const merged = this.buckets[a]!.concat(this.buckets[b]!);\n      this.buckets.splice(a, 2, merged);\n      this.maybeSplit(a);\n    }\n  }\n\n  /** Lookup by an arbitrary comparison closure: which (bucket, local index) does it point to? O(log n). Callers must ensure buckets is non-empty. */\n  private locateBy(compare: (candidate: T) => number, bias: Bias): BucketLocation {\n    const bucketIndex = bisectByCompare(\n      this.buckets.length,\n      (i) => {\n        const bucket = this.buckets[i]!;\n        return bucket[bucket.length - 1]!;\n      },\n      compare,\n      bias,\n    );\n    const clampedBucketIndex = Math.min(bucketIndex, this.buckets.length - 1);\n    const bucket = this.buckets[clampedBucketIndex]!;\n    const localIndex = bisectByCompare(bucket.length, (i) => bucket[i]!, compare, bias);\n    return { bucketIndex: clampedBucketIndex, localIndex };\n  }\n\n  /** Value-based lookup: which (bucket, local index) does `value` belong at? O(log n). Callers must ensure buckets is non-empty. */\n  private locate(value: T, bias: Bias): BucketLocation {\n    return this.locateBy((candidate) => this.comparator(candidate, value), bias);\n  }\n\n  /** Position-based lookup: which (bucket, local index) is global index `index` at? O(√n). */\n  private locatePosition(index: number): BucketLocation | undefined {\n    if (index < 0 || index >= this.count) {\n      return undefined;\n    }\n    let remaining = index;\n    for (let i = 0; i < this.buckets.length; i++) {\n      const bucket = this.buckets[i]!;\n      if (remaining < bucket.length) {\n        return { bucketIndex: i, localIndex: remaining };\n      }\n      remaining -= bucket.length;\n    }\n    /* v8 ignore next -- unreachable unless `count` desyncs from `buckets`, which would be an internal bug */\n    throw new Error('BucketEngine: internal invariant violated (count out of sync with buckets)');\n  }\n\n  /** Inverse of {@link locatePosition}: sums preceding bucket lengths. O(√n). */\n  private globalIndex(bucketIndex: number, localIndex: number): number {\n    let total = localIndex;\n    for (let i = 0; i < bucketIndex; i++) {\n      total += this.buckets[i]!.length;\n    }\n    return total;\n  }\n\n  private resolveIndex(index: number): number {\n    return index < 0 ? this.count + index : index;\n  }\n\n  private *iterateRange(start: BucketLocation, end?: BucketLocation): Generator<T> {\n    for (let bucketIndex = start.bucketIndex; bucketIndex < this.buckets.length; bucketIndex++) {\n      if (end && bucketIndex > end.bucketIndex) {\n        return;\n      }\n      const bucket = this.buckets[bucketIndex]!;\n      const from = bucketIndex === start.bucketIndex ? start.localIndex : 0;\n      const to = end && bucketIndex === end.bucketIndex ? end.localIndex : bucket.length;\n      for (let i = from; i < to; i++) {\n        yield bucket[i]!;\n      }\n    }\n  }\n\n  /** O(√n) amortized: locates the target bucket and splices the value in, splitting oversized buckets. */\n  add(value: T): void {\n    if (this.buckets.length === 0) {\n      this.buckets.push([value]);\n      this.count += 1;\n      return;\n    }\n    const { bucketIndex, localIndex } = this.locate(value, 'right');\n    this.buckets[bucketIndex]!.splice(localIndex, 0, value);\n    this.count += 1;\n    this.maybeSplit(bucketIndex);\n  }\n\n  /**\n   * Replaces the stored element equal to `value` (by comparator) in place, or\n   * inserts it if absent. O(log n) to locate; O(1) to replace in place, or\n   * O(√n) amortized to insert. This is what backs `SortedMap#set` — cheaper\n   * than a separate find-then-remove-then-add round trip.\n   */\n  set(value: T): void {\n    if (this.buckets.length === 0) {\n      this.buckets.push([value]);\n      this.count += 1;\n      return;\n    }\n    const { bucketIndex, localIndex } = this.locate(value, 'left');\n    const bucket = this.buckets[bucketIndex]!;\n    if (localIndex < bucket.length && this.comparator(bucket[localIndex]!, value) === 0) {\n      bucket[localIndex] = value;\n      return;\n    }\n    bucket.splice(localIndex, 0, value);\n    this.count += 1;\n    this.maybeSplit(bucketIndex);\n  }\n\n  remove(value: T): boolean {\n    return this.removeBy((candidate) => this.comparator(candidate, value));\n  }\n\n  /** Same O(log n) path as {@link remove}, via an arbitrary comparison closure instead of a full value. */\n  removeBy(compare: (candidate: T) => number): boolean {\n    if (this.buckets.length === 0) {\n      return false;\n    }\n    const { bucketIndex, localIndex } = this.locateBy(compare, 'left');\n    const bucket = this.buckets[bucketIndex]!;\n    if (localIndex >= bucket.length || compare(bucket[localIndex]!) !== 0) {\n      return false;\n    }\n    bucket.splice(localIndex, 1);\n    this.count -= 1;\n    this.maybeMerge(bucketIndex);\n    return true;\n  }\n\n  discard(value: T): void {\n    this.remove(value);\n  }\n\n  pop(index?: number): T {\n    if (this.count === 0) {\n      throw new RangeError('SortedList#pop: list is empty');\n    }\n    const resolved = index === undefined ? this.count - 1 : this.resolveIndex(index);\n    const location = this.locatePosition(resolved);\n    if (!location) {\n      throw new RangeError(`SortedList#pop: index ${index} is out of range`);\n    }\n    const bucket = this.buckets[location.bucketIndex]!;\n    const [value] = bucket.splice(location.localIndex, 1);\n    this.count -= 1;\n    this.maybeMerge(location.bucketIndex);\n    return value as T;\n  }\n\n  /** O(√n): walks bucket lengths to find the element at `index` (negative indices count from the end). */\n  at(index: number): T | undefined {\n    const location = this.locatePosition(this.resolveIndex(index));\n    if (!location) {\n      return undefined;\n    }\n    return this.buckets[location.bucketIndex]![location.localIndex];\n  }\n\n  indexOf(value: T): number {\n    if (this.buckets.length === 0) {\n      return -1;\n    }\n    const { bucketIndex, localIndex } = this.locate(value, 'left');\n    const bucket = this.buckets[bucketIndex]!;\n    if (localIndex >= bucket.length || this.comparator(bucket[localIndex]!, value) !== 0) {\n      return -1;\n    }\n    return this.globalIndex(bucketIndex, localIndex);\n  }\n\n  /** O(log n): binary search for the bucket, then binary search within it. */\n  has(value: T): boolean {\n    return this.hasBy((candidate) => this.comparator(candidate, value));\n  }\n\n  /** Same O(log n) path as {@link has}, via an arbitrary comparison closure instead of a full value. */\n  hasBy(compare: (candidate: T) => number): boolean {\n    return this.findBy(compare) !== undefined;\n  }\n\n  /** Same O(log n) path as {@link has}, but returns the actual stored element instead of a boolean. */\n  findBy(compare: (candidate: T) => number): T | undefined {\n    if (this.buckets.length === 0) {\n      return undefined;\n    }\n    const { bucketIndex, localIndex } = this.locateBy(compare, 'left');\n    const bucket = this.buckets[bucketIndex]!;\n    return localIndex < bucket.length && compare(bucket[localIndex]!) === 0\n      ? bucket[localIndex]\n      : undefined;\n  }\n\n  bisectLeft(value: T): number {\n    if (this.buckets.length === 0) {\n      return 0;\n    }\n    const { bucketIndex, localIndex } = this.locate(value, 'left');\n    return this.globalIndex(bucketIndex, localIndex);\n  }\n\n  bisectRight(value: T): number {\n    if (this.buckets.length === 0) {\n      return 0;\n    }\n    const { bucketIndex, localIndex } = this.locate(value, 'right');\n    return this.globalIndex(bucketIndex, localIndex);\n  }\n\n  /** O(log n) to locate both bounds by value + O(k) to iterate the k results. */\n  irange(min?: T, max?: T, options?: { inclusive?: [boolean, boolean] }): IterableIterator<T> {\n    if (this.buckets.length === 0) {\n      return this.iterateRange({ bucketIndex: 0, localIndex: 0 });\n    }\n    const [minInclusive, maxInclusive] = options?.inclusive ?? [true, true];\n    const start =\n      min === undefined\n        ? { bucketIndex: 0, localIndex: 0 }\n        : this.locate(min, minInclusive ? 'left' : 'right');\n    const end = max === undefined ? undefined : this.locate(max, maxInclusive ? 'right' : 'left');\n    return this.iterateRange(start, end);\n  }\n\n  /**\n   * O(√n) to locate both positional bounds + O(k) to iterate the k results.\n   * (Slightly worse than the O(log n) originally targeted for this method —\n   * positional lookup fundamentally needs a bucket-length walk without a\n   * Fenwick index. Confirmed empirically via `npm run bench`.)\n   */\n  islice(start?: number, end?: number): IterableIterator<T> {\n    const resolvedStart = Math.max(0, start === undefined ? 0 : this.resolveIndex(start));\n    const resolvedEnd = Math.min(\n      this.count,\n      end === undefined ? this.count : this.resolveIndex(end),\n    );\n    if (resolvedStart >= resolvedEnd || this.count === 0) {\n      return this.iterateRange(\n        { bucketIndex: 0, localIndex: 0 },\n        { bucketIndex: 0, localIndex: 0 },\n      );\n    }\n    const startLoc = this.locatePosition(resolvedStart)!;\n    const endLoc = this.locatePosition(resolvedEnd - 1)!;\n    return this.iterateRange(startLoc, {\n      bucketIndex: endLoc.bucketIndex,\n      localIndex: endLoc.localIndex + 1,\n    });\n  }\n\n  get length(): number {\n    return this.count;\n  }\n\n  clear(): void {\n    this.buckets = [];\n    this.count = 0;\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.iterateRange({ bucketIndex: 0, localIndex: 0 });\n  }\n}\n","import { BucketEngine } from './internal/bucket-engine.js';\nimport type { Comparator, ComparatorArg, SortedOptions } from './types.js';\n\nfunction defaultComparator<T>(a: T, b: T): number {\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n  const left = String(a);\n  const right = String(b);\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n\n/**\n * A list that keeps its elements in sorted order as they're inserted.\n *\n * A thin public wrapper around the internal {@link BucketEngine} — see there\n * for the actual \"list of lists\" (sqrt-decomposition) implementation and its\n * complexity notes.\n *\n * @example\n * ```ts\n * const scores = new SortedList<number>([42, 7, 99]);\n * scores.add(15);\n * [...scores]; // [7, 15, 42, 99]\n * ```\n */\nexport class SortedList<T> implements Iterable<T> {\n  private readonly engine: BucketEngine<T>;\n\n  /**\n   * @example\n   * ```ts\n   * new SortedList<number>(); // empty\n   * new SortedList<number>([3, 1, 2]); // [1, 2, 3]\n   * new SortedList<Person>([...], { comparator: (a, b) => a.age - b.age });\n   * ```\n   */\n  constructor(iterable?: Iterable<T>, ...options: ComparatorArg<T>) {\n    const opts = options[0] as SortedOptions<T> | undefined;\n    const comparator = opts?.comparator ?? (defaultComparator as Comparator<T>);\n    this.engine = new BucketEngine<T>(comparator);\n    // Goes through `this.update` -> `this.add` (not the engine's) so that a\n    // SortedSet's overridden, deduping `add` applies during construction too.\n    if (iterable) {\n      this.update(iterable);\n    }\n  }\n\n  /** Safe to call from subclasses/clone: both `ComparatorArg<T>` branches accept `{ comparator }`. */\n  protected comparatorArg(): ComparatorArg<T> {\n    return [{ comparator: this.engine.comparator }] as unknown as ComparatorArg<T>;\n  }\n\n  /**\n   * O(√n) amortized.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>();\n   * scores.add(42);\n   * scores.add(7);\n   * [...scores]; // [7, 42]\n   * ```\n   */\n  add(value: T): void {\n    this.engine.add(value);\n  }\n\n  /**\n   * Bulk-inserts every value from `iterable`, one {@link add} at a time.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([3, 1]);\n   * scores.update([2, 5, 4]);\n   * [...scores]; // [1, 2, 3, 4, 5]\n   * ```\n   */\n  update(iterable: Iterable<T>): void {\n    for (const value of iterable) {\n      this.add(value);\n    }\n  }\n\n  /**\n   * Removes the first occurrence of `value`. Returns `false` if it wasn't present.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([1, 2, 2, 3]);\n   * scores.remove(2); // true — removes one occurrence\n   * scores.remove(99); // false — not present\n   * ```\n   */\n  remove(value: T): boolean {\n    return this.engine.remove(value);\n  }\n\n  /**\n   * Like {@link remove}, but never throws (or returns anything) if `value` isn't present.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([1, 2, 3]);\n   * scores.discard(99); // no-op, no error\n   * ```\n   */\n  discard(value: T): void {\n    this.engine.discard(value);\n  }\n\n  /**\n   * Removes and returns the element at `index` (default: the last element).\n   * Negative indices count from the end, same as {@link at}.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([10, 20, 30]);\n   * scores.pop(); // 30 — last element\n   * scores.pop(0); // 10 — first element\n   * ```\n   */\n  pop(index?: number): T {\n    return this.engine.pop(index);\n  }\n\n  /**\n   * O(√n): walks bucket lengths to find the element at `index` (negative indices count from the end).\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([10, 20, 30]);\n   * scores.at(0); // 10\n   * scores.at(-1); // 30 — same as Array.prototype.at\n   * scores.at(99); // undefined — out of range\n   * ```\n   */\n  at(index: number): T | undefined {\n    return this.engine.at(index);\n  }\n\n  /**\n   * The index of the first occurrence of `value`, or `-1` if absent.\n   *\n   * @example\n   * ```ts\n   * new SortedList<number>([1, 2, 2, 3]).indexOf(2); // 1\n   * new SortedList<number>([1, 2, 3]).indexOf(99); // -1\n   * ```\n   */\n  indexOf(value: T): number {\n    return this.engine.indexOf(value);\n  }\n\n  /**\n   * O(log n): binary search for the bucket, then binary search within it.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([1, 2, 3]);\n   * scores.has(2); // true\n   * scores.has(99); // false\n   * ```\n   */\n  has(value: T): boolean {\n    return this.engine.has(value);\n  }\n\n  /**\n   * The leftmost index where `value` could be inserted while keeping the list sorted.\n   *\n   * @example\n   * ```ts\n   * new SortedList<number>([1, 2, 2, 2, 3]).bisectLeft(2); // 1\n   * ```\n   */\n  bisectLeft(value: T): number {\n    return this.engine.bisectLeft(value);\n  }\n\n  /**\n   * The rightmost index where `value` could be inserted while keeping the list sorted.\n   *\n   * @example\n   * ```ts\n   * new SortedList<number>([1, 2, 2, 2, 3]).bisectRight(2); // 4\n   * ```\n   */\n  bisectRight(value: T): number {\n    return this.engine.bisectRight(value);\n  }\n\n  /**\n   * O(log n) to locate both bounds by value + O(k) to iterate the k results.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([1, 2, 3, 4, 5]);\n   * [...scores.irange(2, 4)]; // [2, 3, 4] — inclusive by default\n   * [...scores.irange(2, 4, { inclusive: [false, true] })]; // [3, 4]\n   * ```\n   */\n  irange(min?: T, max?: T, options?: { inclusive?: [boolean, boolean] }): IterableIterator<T> {\n    return this.engine.irange(min, max, options);\n  }\n\n  /**\n   * O(√n) to locate both positional bounds + O(k) to iterate the k results.\n   *\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([10, 20, 30, 40, 50]);\n   * [...scores.islice(1, 4)]; // [20, 30, 40] — like Array.prototype.slice\n   * ```\n   */\n  islice(start?: number, end?: number): IterableIterator<T> {\n    return this.engine.islice(start, end);\n  }\n\n  /**\n   * @example\n   * ```ts\n   * new SortedList<number>([1, 2, 3]).length; // 3\n   * ```\n   */\n  get length(): number {\n    return this.engine.length;\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([1, 2, 3]);\n   * scores.clear();\n   * scores.length; // 0\n   * ```\n   */\n  clear(): void {\n    this.engine.clear();\n  }\n\n  /**\n   * An independent copy — mutating the clone never affects the original.\n   *\n   * @example\n   * ```ts\n   * const original = new SortedList<number>([1, 2, 3]);\n   * const copy = original.clone();\n   * copy.add(4);\n   * original.length; // 3\n   * copy.length; // 4\n   * ```\n   */\n  clone(): SortedList<T> {\n    return new SortedList<T>(this, ...this.comparatorArg());\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const scores = new SortedList<number>([3, 1, 2]);\n   * for (const value of scores) console.log(value); // 1, 2, 3\n   * ```\n   */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.engine[Symbol.iterator]();\n  }\n}\n","import { SortedList } from './sorted-list.js';\n\n/**\n * Like {@link SortedList}, but rejects duplicates (compared via the\n * comparator, not reference identity). Adds set-theory operations.\n *\n * Reuses `SortedList`'s bucket structure entirely: the only behavioral\n * difference is that `add` is a no-op for values already present.\n *\n * @example\n * ```ts\n * const tags = new SortedSet<string>(['b', 'a', 'c', 'a']);\n * [...tags]; // ['a', 'b', 'c'] — the duplicate 'a' was dropped\n * ```\n */\nexport class SortedSet<T> extends SortedList<T> {\n  /**\n   * O(log n) `has` check + O(√n) amortized insert if the value is new.\n   *\n   * @example\n   * ```ts\n   * const tags = new SortedSet<string>(['a']);\n   * tags.add('a'); // no-op, already present\n   * tags.length; // 1\n   * ```\n   */\n  override add(value: T): void {\n    if (!this.has(value)) {\n      super.add(value);\n    }\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const original = new SortedSet<number>([1, 2, 3]);\n   * const copy = original.clone();\n   * copy.add(4);\n   * original.length; // 3\n   * ```\n   */\n  override clone(): SortedSet<T> {\n    return new SortedSet<T>(this, ...this.comparatorArg());\n  }\n\n  /**\n   * O(m log n + m) for a set of size m being merged in.\n   *\n   * @example\n   * ```ts\n   * const a = new SortedSet<number>([1, 2, 3]);\n   * const b = new SortedSet<number>([3, 4]);\n   * [...a.union(b)]; // [1, 2, 3, 4]\n   * ```\n   */\n  union(other: SortedSet<T>): SortedSet<T> {\n    const result = this.clone();\n    for (const value of other) {\n      result.add(value);\n    }\n    return result;\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const a = new SortedSet<number>([1, 2, 3]);\n   * const b = new SortedSet<number>([2, 3, 4]);\n   * [...a.intersection(b)]; // [2, 3]\n   * ```\n   */\n  intersection(other: SortedSet<T>): SortedSet<T> {\n    const result = new SortedSet<T>([], ...this.comparatorArg());\n    for (const value of this) {\n      if (other.has(value)) {\n        result.add(value);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const a = new SortedSet<number>([1, 2, 3]);\n   * const b = new SortedSet<number>([2, 3]);\n   * [...a.difference(b)]; // [1] — in a, not in b\n   * ```\n   */\n  difference(other: SortedSet<T>): SortedSet<T> {\n    const result = new SortedSet<T>([], ...this.comparatorArg());\n    for (const value of this) {\n      if (!other.has(value)) {\n        result.add(value);\n      }\n    }\n    return result;\n  }\n\n  /**\n   * @example\n   * ```ts\n   * new SortedSet<number>([2, 3]).isSubsetOf(new SortedSet<number>([1, 2, 3, 4])); // true\n   * new SortedSet<number>([1, 5]).isSubsetOf(new SortedSet<number>([1, 2, 3])); // false\n   * ```\n   */\n  isSubsetOf(other: SortedSet<T>): boolean {\n    for (const value of this) {\n      if (!other.has(value)) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n","import { BucketEngine } from './internal/bucket-engine.js';\nimport { SortedSet } from './sorted-set.js';\nimport type { Comparator, ComparatorArg, SortedOptions } from './types.js';\n\nfunction defaultKeyComparator<K>(a: K, b: K): number {\n  if (typeof a === 'number' && typeof b === 'number') {\n    return a - b;\n  }\n  const left = String(a);\n  const right = String(b);\n  if (left < right) return -1;\n  if (left > right) return 1;\n  return 0;\n}\n\nfunction comparatorArgs<T>(comparator: Comparator<T>): ComparatorArg<T> {\n  return [{ comparator }] as unknown as ComparatorArg<T>;\n}\n\n/**\n * A dictionary ordered by key.\n *\n * Uses the internal {@link BucketEngine} directly (on `[K, V]` tuples, with a\n * comparator that only looks at the key) rather than composing over\n * `SortedList`'s public API. Two reasons: `set` needs the engine's O(log n)\n * in-place replace-or-insert (`SortedList#bisectLeft` + `#at` would pay for a\n * positional index it doesn't need), and `get`/`has`/`delete` use the `*By`\n * lookup methods with a closure over the bare key — that compares the key\n * only once per candidate (not twice, since the search side needs no\n * `entry[0]` unwrapping) and avoids allocating a throwaway `[key, undefined]`\n * search tuple per call.\n *\n * @example\n * ```ts\n * const byPrice = new SortedMap<number, string>([[101.5, 'order-1'], [99.75, 'order-2']]);\n * [...byPrice.keys()]; // [99.75, 101.5]\n * ```\n */\nexport class SortedMap<K, V> implements Iterable<[K, V]> {\n  private readonly engine: BucketEngine<[K, V]>;\n  private readonly keyComparator: Comparator<K>;\n\n  /**\n   * @example\n   * ```ts\n   * new SortedMap<number, string>(); // empty\n   * new SortedMap<number, string>([[2, 'b'], [1, 'a']]); // ordered by key: 1, 2\n   * ```\n   */\n  constructor(entries?: Iterable<[K, V]>, ...options: ComparatorArg<K>) {\n    const opts = options[0] as SortedOptions<K> | undefined;\n    this.keyComparator = opts?.comparator ?? (defaultKeyComparator as Comparator<K>);\n    const entryComparator: Comparator<[K, V]> = (a, b) => this.keyComparator(a[0], b[0]);\n    this.engine = new BucketEngine<[K, V]>(entryComparator);\n    if (entries) {\n      for (const [key, value] of entries) {\n        this.set(key, value);\n      }\n    }\n  }\n\n  /**\n   * O(log n) to locate + O(1) to replace in place, or O(√n) amortized to insert.\n   *\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>();\n   * byPrice.set(101.5, 'order-1');\n   * byPrice.set(101.5, 'order-1-updated'); // overwrites, doesn't grow size\n   * ```\n   */\n  set(key: K, value: V): void {\n    this.engine.set([key, value]);\n  }\n\n  /**\n   * O(log n): binary search for the bucket, then binary search within it.\n   *\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[101.5, 'order-1']]);\n   * byPrice.get(101.5); // 'order-1'\n   * byPrice.get(1); // undefined\n   * ```\n   */\n  get(key: K): V | undefined {\n    return this.engine.findBy((entry) => this.keyComparator(entry[0], key))?.[1];\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[101.5, 'order-1']]);\n   * byPrice.delete(101.5); // true\n   * byPrice.delete(101.5); // false — already gone\n   * ```\n   */\n  delete(key: K): boolean {\n    return this.engine.removeBy((entry) => this.keyComparator(entry[0], key));\n  }\n\n  /**\n   * @example\n   * ```ts\n   * new SortedMap<number, string>([[1, 'a']]).has(1); // true\n   * ```\n   */\n  has(key: K): boolean {\n    return this.engine.hasBy((entry) => this.keyComparator(entry[0], key));\n  }\n\n  /**\n   * A snapshot `SortedSet` of the current keys — not a live view.\n   *\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[2, 'b'], [1, 'a']]);\n   * [...byPrice.keys()]; // [1, 2]\n   * ```\n   */\n  keys(): SortedSet<K> {\n    return new SortedSet<K>(this.keysGenerator(), ...comparatorArgs(this.keyComparator));\n  }\n\n  private *keysGenerator(): Generator<K> {\n    for (const [key] of this.engine) {\n      yield key;\n    }\n  }\n\n  /**\n   * @example\n   * ```ts\n   * [...new SortedMap<number, string>([[2, 'b'], [1, 'a']]).values()]; // ['a', 'b']\n   * ```\n   */\n  *values(): IterableIterator<V> {\n    for (const [, value] of this.engine) {\n      yield value;\n    }\n  }\n\n  /**\n   * @example\n   * ```ts\n   * [...new SortedMap<number, string>([[2, 'b'], [1, 'a']]).entries()]; // [[1, 'a'], [2, 'b']]\n   * ```\n   */\n  entries(): IterableIterator<[K, V]> {\n    return this.engine[Symbol.iterator]();\n  }\n\n  /**\n   * Iterates `[key, value]` pairs with keys in `[minKey, maxKey]`.\n   *\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[95, 'a'], [100, 'b'], [105, 'c']]);\n   * [...byPrice.irange(95, 100)]; // [[95, 'a'], [100, 'b']]\n   * ```\n   */\n  irange(minKey?: K, maxKey?: K): IterableIterator<[K, V]> {\n    const min = minKey === undefined ? undefined : ([minKey, undefined as unknown as V] as [K, V]);\n    const max = maxKey === undefined ? undefined : ([maxKey, undefined as unknown as V] as [K, V]);\n    return this.engine.irange(min, max);\n  }\n\n  /**\n   * O(√n). Entry at ordinal position `index` in key order.\n   *\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[2, 'b'], [1, 'a']]);\n   * byPrice.at(0); // [1, 'a']\n   * ```\n   */\n  at(index: number): [K, V] | undefined {\n    return this.engine.at(index);\n  }\n\n  /**\n   * @example\n   * ```ts\n   * new SortedMap<number, string>([[1, 'a'], [2, 'b']]).size; // 2\n   * ```\n   */\n  get size(): number {\n    return this.engine.length;\n  }\n\n  /**\n   * @example\n   * ```ts\n   * const byPrice = new SortedMap<number, string>([[1, 'a']]);\n   * byPrice.clear();\n   * byPrice.size; // 0\n   * ```\n   */\n  clear(): void {\n    this.engine.clear();\n  }\n\n  /**\n   * @example\n   * ```ts\n   * for (const [key, value] of new SortedMap([[2, 'b'], [1, 'a']])) {\n   *   console.log(key, value); // 1 'a', then 2 'b'\n   * }\n   * ```\n   */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.engine[Symbol.iterator]();\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "sorted-collections",
+  "version": "1.0.2",
+  "description": "SortedList, SortedSet and SortedMap for JavaScript/TypeScript — zero runtime dependencies, inspired by Python's sortedcontainers.",
+  "keywords": [
+    "sorted",
+    "sorted-list",
+    "sorted-set",
+    "sorted-map",
+    "data-structures",
+    "sortedcontainers",
+    "typescript"
+  ],
+  "homepage": "https://johansneirap.github.io/sorted-collections/",
+  "bugs": {
+    "url": "https://github.com/johansneirap/sorted-collections/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johansneirap/sorted-collections.git"
+  },
+  "license": "MIT",
+  "author": "Johans Neira",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "bench": "tsx benchmarks/run.ts",
+    "lint": "biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "typecheck": "tsc --noEmit",
+    "changeset": "changeset",
+    "docs:api": "typedoc",
+    "docs:dev": "npm run docs:api && vitepress dev docs-site",
+    "docs:build": "npm run docs:api && vitepress build docs-site",
+    "docs:preview": "vitepress preview docs-site",
+    "prepublishOnly": "npm run format:check && npm run lint && npm run typecheck && npm run test && npm run build"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.3",
+    "@changesets/cli": "^2.31.0",
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "fast-check": "^4.9.0",
+    "sorted-containers": "^0.4.0",
+    "sortedkit": "^0.1.0",
+    "tinybench": "^6.0.2",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.0",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-markdown": "^4.12.0",
+    "typedoc-vitepress-theme": "^1.1.3",
+    "typescript": "^6.0.3",
+    "vitepress": "^1.6.4",
+    "vitest": "^4.1.10",
+    "vue": "^3.5.39"
+  },
+  "packageManager": "npm@11.8.0"
+}