@isopodlabs/utilities 1.5.8 → 1.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/dist/bits.d.ts +94 -56
  2. package/dist/bits.js +651 -381
  3. package/package.json +1 -1
package/dist/bits.d.ts CHANGED
@@ -1,111 +1,149 @@
1
1
  export declare function lowestSet32(x: number): number;
2
2
  export declare function highestSet32(x: number): number;
3
+ export declare function highestSet1024(x: number): number;
3
4
  export declare function countSet32(x: number): number;
5
+ export declare function nthSet32(x: number, i: number): number;
4
6
  export declare function highestSet(x: bigint | number): number;
5
7
  export declare function lowestSet(x: number | bigint): number;
6
8
  export declare function countSet(x: bigint | number): number;
9
+ export declare function nthSet(x: bigint | number, i: number): number;
7
10
  export declare function highestClear(x: number | bigint): number;
8
11
  export declare function lowestClear(x: number | bigint): number;
9
12
  export declare function countClear(x: bigint | number): number;
10
- export interface immutableBitSet {
13
+ export declare function clearLowest(x: bigint): bigint;
14
+ export declare function clearLowest(x: number): number;
15
+ export declare function clearLowest(x: bigint | number): bigint | number;
16
+ export interface ImmutableBitSet {
17
+ test(a: number): boolean;
11
18
  countSet(): number;
12
- complement(): this;
13
- intersect(other: this): this;
14
- union(other: this): this;
15
- xor(other: this): this;
19
+ nthSet(a: number): number;
20
+ complement(): ImmutableBitSet;
21
+ intersect(other: this): ImmutableBitSet;
22
+ union(other: this): ImmutableBitSet;
23
+ xor(other: this): ImmutableBitSet;
16
24
  contains(other: this): boolean;
17
- test(a: number): boolean;
18
25
  next(a: number, set: boolean): number;
19
- where(set: boolean, from?: number): {
26
+ where(set: boolean, from?: number, to?: number): {
20
27
  [Symbol.iterator](): Generator<number>;
21
28
  };
22
29
  ranges(): {
23
30
  [Symbol.iterator](): Generator<number[]>;
24
31
  };
32
+ slice(from: number, to?: number): ImmutableBitSet;
33
+ [Symbol.iterator](): Generator<number>;
25
34
  }
26
- export interface BitSet extends immutableBitSet {
35
+ export interface BitSet extends ImmutableBitSet {
27
36
  set(a: number): void;
28
37
  clear(a: number): void;
29
38
  setRange(a: number, b: number): this;
30
39
  clearRange(a: number, b: number): this;
31
- selfComplement(): this;
40
+ selfComplement?(): this;
32
41
  selfIntersect(other: this): this;
33
42
  selfUnion(other: this): this;
34
43
  selfXor(other: this): this;
35
44
  }
36
- export declare class ImmutableSparseBits implements immutableBitSet {
45
+ export declare class ImmutableDenseBits implements ImmutableBitSet {
46
+ protected bits: bigint;
47
+ constructor(bits?: bigint);
48
+ protected create(bits?: bigint): this;
49
+ get length(): number;
50
+ test(a: number): boolean;
51
+ countSet(): number;
52
+ nthSet(a: number): number;
53
+ complement(): this;
54
+ intersect(other: ImmutableDenseBits): this;
55
+ union(other: ImmutableDenseBits): this;
56
+ xor(other: ImmutableDenseBits): this;
57
+ contains(other: this): boolean;
58
+ next(a: number, set?: boolean): number;
59
+ where(set: boolean, from?: number, to?: number): {
60
+ [Symbol.iterator](): Generator<number>;
61
+ };
62
+ ranges(): {
63
+ [Symbol.iterator](): Generator<number[]>;
64
+ };
65
+ [Symbol.iterator](): Generator<number>;
66
+ toSparse(): SparseBits2;
67
+ slice(from: number, to?: number): ImmutableBitSet;
68
+ }
69
+ export declare class DenseBits extends ImmutableDenseBits implements BitSet {
70
+ protected setMask(m: bigint): void;
71
+ protected clearMask(m: bigint): void;
72
+ set(a: number): void;
73
+ clear(a: number): void;
74
+ setRange(a: number, b: number): this;
75
+ clearRange(a: number, b: number): this;
76
+ selfComplement(): this;
77
+ selfIntersect(other: DenseBits): this;
78
+ selfUnion(other: DenseBits): this;
79
+ selfXor(other: DenseBits): this;
80
+ }
81
+ export declare class ImmutableSparseBits implements ImmutableBitSet {
37
82
  protected bits: number[];
38
- protected undef: number;
39
- static whereGenerator(bits: number[], undef: number, set: boolean, from?: number): Generator<number>;
40
- constructor(initial?: boolean);
41
- protected create(init?: boolean): this;
42
- protected copyUndefined(other: ImmutableSparseBits): this;
43
- protected flipUndefined(other: ImmutableSparseBits): this;
44
- static fromEntries<T extends ImmutableSparseBits>(this: new (initial?: boolean) => T, entries: Record<number, number> | [number, number][], initial?: boolean): T;
83
+ constructor(bits?: number[]);
84
+ protected create(bits?: number[]): this;
85
+ static fromEntries<T extends ImmutableSparseBits>(this: new (...args: any[]) => T, entries: Record<number, number> | [number, number][], ...args: any[]): T;
45
86
  keys(): number[];
46
87
  entries(): [number, number][];
47
- complement(): this;
88
+ test(a: number): boolean;
89
+ countSet(): number;
90
+ nthSet(a: number): number;
91
+ complement(): ImmutableSparseBits2;
48
92
  intersect(other: ImmutableSparseBits): this;
49
93
  union(other: ImmutableSparseBits): this;
50
94
  xor(other: ImmutableSparseBits): this;
51
- clean(): this;
52
95
  contains(other: ImmutableSparseBits): boolean;
53
- test(a: number): boolean;
54
- countSet(): number;
55
- next(a: number, set?: boolean): number;
56
- toDense(): DenseBits;
57
- where(set: boolean, from?: number): {
58
- [Symbol.iterator]: () => Generator<number, any, any>;
96
+ next(from: number, set?: boolean): number;
97
+ where(set: boolean, from?: number, to?: number): {
98
+ [Symbol.iterator]: () => Generator<number, void, unknown>;
59
99
  };
60
100
  ranges(): {
61
- [Symbol.iterator](): Generator<number[]>;
101
+ [Symbol.iterator]: () => Generator<number[], void, unknown>;
62
102
  };
63
103
  [Symbol.iterator](): Generator<number>;
104
+ clean(): this;
105
+ toDense(): DenseBits;
106
+ slice(from: number, to?: number): ImmutableBitSet;
64
107
  }
65
108
  export declare class SparseBits extends ImmutableSparseBits implements BitSet {
66
- private setMask;
67
- private clearMask;
68
- selfComplement(): this;
69
- selfIntersect(other: SparseBits): this;
70
- selfUnion(other: SparseBits): this;
71
- selfXor(other: SparseBits): this;
72
109
  set(a: number): void;
73
110
  clear(a: number): void;
74
- test(a: number): boolean;
75
111
  setRange(a: number, b: number): this;
76
112
  clearRange(a: number, b: number): this;
113
+ selfIntersect(other: SparseBits): this;
114
+ selfUnion(other: SparseBits): this;
115
+ selfXor(other: SparseBits): this;
77
116
  }
78
- export declare class ImmutableDenseBits implements immutableBitSet {
79
- protected bits: bigint;
80
- constructor(bits?: bigint);
81
- protected create(bits?: bigint): this;
82
- complement(): this;
83
- intersect(other: ImmutableDenseBits): this;
84
- union(other: ImmutableDenseBits): this;
85
- xor(other: ImmutableDenseBits): this;
117
+ export declare class ImmutableSparseBits2 extends ImmutableSparseBits {
118
+ protected undef: number;
119
+ constructor(bits?: number[], initial?: boolean);
120
+ protected create(bits?: number[], init?: boolean): this;
86
121
  test(a: number): boolean;
87
- contains(other: this): boolean;
88
- next(a: number, set?: boolean): number;
89
- countSet(): number;
90
- get length(): number;
91
- where(set: boolean, from?: number): {
92
- [Symbol.iterator](): Generator<number>;
122
+ nthSet(a: number): number;
123
+ complement(): this;
124
+ intersect(other: ImmutableSparseBits2): this;
125
+ union(other: ImmutableSparseBits2): this;
126
+ xor(other: ImmutableSparseBits2): this;
127
+ contains(other: ImmutableSparseBits2): boolean;
128
+ next(from: number, set?: boolean): number;
129
+ where(set: boolean, from?: number, to?: number): {
130
+ [Symbol.iterator]: () => Generator<number, void, unknown>;
93
131
  };
94
132
  ranges(): {
95
- [Symbol.iterator](): Generator<number[]>;
133
+ [Symbol.iterator]: () => Generator<number[], void, unknown>;
96
134
  };
97
135
  [Symbol.iterator](): Generator<number>;
98
- toSparse(): SparseBits;
136
+ clean(): this;
137
+ toDense(): DenseBits;
138
+ slice(from: number, to?: number): ImmutableBitSet;
99
139
  }
100
- export declare class DenseBits extends ImmutableDenseBits implements BitSet {
101
- private setMask;
102
- private clearMask;
103
- selfComplement(): this;
104
- selfIntersect(other: DenseBits): this;
105
- selfUnion(other: DenseBits): this;
106
- selfXor(other: DenseBits): this;
140
+ export declare class SparseBits2 extends ImmutableSparseBits2 implements BitSet {
107
141
  set(a: number): void;
108
142
  clear(a: number): void;
109
143
  setRange(a: number, b: number): this;
110
144
  clearRange(a: number, b: number): this;
145
+ selfComplement(): this;
146
+ selfIntersect(other: SparseBits2): this;
147
+ selfUnion(other: SparseBits2): this;
148
+ selfXor(other: SparseBits2): this;
111
149
  }