@isopodlabs/utilities 1.5.6 → 1.5.8

package/dist/bits.d.ts

@@ -7,7 +7,33 @@ export declare function countSet(x: bigint | number): number;
 export declare function highestClear(x: number | bigint): number;
 export declare function lowestClear(x: number | bigint): number;
 export declare function countClear(x: bigint | number): number;
-export declare class ImmutableSparseBits {
+export interface immutableBitSet {
+    countSet(): number;
+    complement(): this;
+    intersect(other: this): this;
+    union(other: this): this;
+    xor(other: this): this;
+    contains(other: this): boolean;
+    test(a: number): boolean;
+    next(a: number, set: boolean): number;
+    where(set: boolean, from?: number): {
+        [Symbol.iterator](): Generator<number>;
+    };
+    ranges(): {
+        [Symbol.iterator](): Generator<number[]>;
+    };
+}
+export interface BitSet extends immutableBitSet {
+    set(a: number): void;
+    clear(a: number): void;
+    setRange(a: number, b: number): this;
+    clearRange(a: number, b: number): this;
+    selfComplement(): this;
+    selfIntersect(other: this): this;
+    selfUnion(other: this): this;
+    selfXor(other: this): this;
+}
+export declare class ImmutableSparseBits implements immutableBitSet {
     protected bits: number[];
     protected undef: number;
     static whereGenerator(bits: number[], undef: number, set: boolean, from?: number): Generator<number>;
@@ -24,7 +50,8 @@ export declare class ImmutableSparseBits {
     xor(other: ImmutableSparseBits): this;
     clean(): this;
     contains(other: ImmutableSparseBits): boolean;
-    has(a: number): boolean;
+    test(a: number): boolean;
+    countSet(): number;
     next(a: number, set?: boolean): number;
     toDense(): DenseBits;
     where(set: boolean, from?: number): {
@@ -35,7 +62,7 @@ export declare class ImmutableSparseBits {
     };
     [Symbol.iterator](): Generator<number>;
 }
-export declare class SparseBits extends ImmutableSparseBits {
+export declare class SparseBits extends ImmutableSparseBits implements BitSet {
     private setMask;
     private clearMask;
     selfComplement(): this;
@@ -44,20 +71,22 @@ export declare class SparseBits extends ImmutableSparseBits {
     selfXor(other: SparseBits): this;
     set(a: number): void;
     clear(a: number): void;
-    has(a: number): boolean;
+    test(a: number): boolean;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
 }
-export declare class ImmutableDenseBits {
+export declare class ImmutableDenseBits implements immutableBitSet {
     protected bits: bigint;
     constructor(bits?: bigint);
     protected create(bits?: bigint): this;
     complement(): this;
-    intersect(other: DenseBits): this;
-    union(other: DenseBits): this;
-    xor(other: DenseBits): this;
-    has(a: number): boolean;
+    intersect(other: ImmutableDenseBits): this;
+    union(other: ImmutableDenseBits): this;
+    xor(other: ImmutableDenseBits): this;
+    test(a: number): boolean;
+    contains(other: this): boolean;
     next(a: number, set?: boolean): number;
+    countSet(): number;
     get length(): number;
     where(set: boolean, from?: number): {
         [Symbol.iterator](): Generator<number>;
@@ -68,7 +97,7 @@ export declare class ImmutableDenseBits {
     [Symbol.iterator](): Generator<number>;
     toSparse(): SparseBits;
 }
-export declare class DenseBits extends ImmutableDenseBits {
+export declare class DenseBits extends ImmutableDenseBits implements BitSet {
     private setMask;
     private clearMask;
     selfComplement(): this;

package/dist/bits.js

@@ -278,9 +278,15 @@ class ImmutableSparseBits {
         }
         return true;
     }
-    has(a) {
+    test(a) {
         return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
     }
+    countSet() {
+        let count = 0;
+        for (const i in this.bits)
+            count += countSet32(this.bits[i]);
+        return count;
+    }
     next(a, set = true) {
         ++a;
         const xor = this.undef;
@@ -429,7 +435,7 @@ class SparseBits extends ImmutableSparseBits {
     clear(a) {
         this.clearMask(a >> 5, 1 << (a & 0x1f));
     }
-    has(a) {
+    test(a) {
         const i = a >> 5;
         return !!((this.bits[i] ?? this.undef) & (1 << (a & 0x1f)));
     }
@@ -497,14 +503,20 @@ class ImmutableDenseBits {
     xor(other) {
         return this.create(this.bits ^ other.bits);
     }
-    has(a) {
+    test(a) {
         return !!(this.bits & (1n << BigInt(a)));
     }
+    contains(other) {
+        return (this.bits & other.bits) === other.bits;
+    }
     next(a, set = true) {
         let s = this.bits >> BigInt(a + 1);
         s = set ? s & -s : (s + 1n) & ~s;
         return s ? a + highestSet(s) : -1;
     }
+    countSet() {
+        return countSet(this.bits);
+    }
     get length() {
         return highestSet(this.bits);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.5.6",
+	"version": "1.5.8",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",

package/dist/regex.d.ts

@@ -1,103 +0,0 @@
-import { SparseBits } from "./bits";
-export declare class characterClass extends SparseBits {
-    type: 'class';
-    test(char: string): boolean;
-    mutable(): MutablecharacterClass;
-    isNegated(): boolean;
-    toString(): string;
-}
-declare class MutablecharacterClass extends characterClass {
-    setChar(char: string): void;
-    setString(c: string): this;
-    clearString(c: string): this;
-}
-export declare function range(from: string, to: string): MutablecharacterClass;
-export declare function chars(chars: string): MutablecharacterClass;
-export declare function union(...classes: characterClass[]): MutablecharacterClass;
-export declare const any: characterClass;
-export declare const digit: characterClass;
-export declare const lower: characterClass;
-export declare const upper: characterClass;
-export declare const alpha: characterClass;
-export declare const alnum: characterClass;
-export declare const word: characterClass;
-export declare const whitespace: characterClass;
-export declare const hex: characterClass;
-export declare const octal: characterClass;
-export declare function text(c: string): string;
-export declare function concatenation(parts: part[]): part[] | part;
-interface alternation {
-    type: 'alt';
-    parts: part[];
-}
-export declare function alternation(parts: part[]): alternation | part;
-type noncaptureOptions = 'ahead' | 'behind' | 'neg_ahead' | 'neg_behind' | 'atomic' | {
-    i?: boolean;
-    m?: boolean;
-    s?: boolean;
-};
-interface noncapture {
-    type: 'noncapture';
-    part: part;
-    options?: noncaptureOptions;
-}
-export declare function noncapture(part: part, options?: noncaptureOptions): noncapture;
-export declare function lookAhead(part: part): noncapture;
-export declare function negLookAhead(part: part): noncapture;
-export declare function lookBehind(part: part): noncapture;
-export declare function negLookBehind(part: part): noncapture;
-interface capture {
-    type: 'capture';
-    name?: string;
-    part: part;
-}
-export declare function capture(part: part, name?: string): capture;
-type quantifiedMod = 'greedy' | 'lazy' | 'possessive';
-interface quantified {
-    type: 'quantified';
-    part: part;
-    min: number;
-    max: number;
-    mod: quantifiedMod;
-}
-export declare function repeatFrom(part: part, min: number, max?: number, mod?: quantifiedMod): quantified;
-export declare function repeat(part: part, n: number, mod?: quantifiedMod): quantified;
-export declare function zeroOrMore(part: part, mod?: quantifiedMod): quantified;
-export declare function oneOrMore(part: part, mod?: quantifiedMod): quantified;
-export declare function optional(part: part, mod?: quantifiedMod): quantified;
-interface boundary {
-    type: 'wordbound' | 'nowordbound' | 'inputboundstart' | 'inputboundend';
-}
-export declare function boundary(type: boundary['type']): boundary;
-export declare const wordBoundary: boundary;
-export declare const nonWordBoundary: boundary;
-export declare const startAnchor: boundary;
-export declare const endAnchor: boundary;
-interface reference {
-    type: 'reference';
-    value: number | string;
-}
-export declare function reference(value: number | string): reference;
-export declare function anchored(part: part): part;
-interface unicode {
-    type: 'unicode' | 'notunicode';
-    property: string;
-}
-type _part = alternation | noncapture | capture | characterClass | unicode | quantified | boundary | reference;
-type part = string | part[] | _part;
-export declare function parse(re: string, unicode?: boolean, extended?: boolean): part;
-export declare function toRegExpString(part: part): string;
-export declare function toRegExp(part: part, flags?: string): RegExp;
-export declare function optimize(part: part): part;
-interface DFAState {
-    nfaStates: Set<number>;
-    transitions: Map<string, DFAState>;
-    isAccepting: boolean;
-}
-export declare function runDFA(dfa: DFAState, str: string): boolean;
-export declare function regexToDFA(part: part): DFAState;
-export declare function parseGlob(glob: string): string;
-export declare function anchoredRe(re: string): RegExp;
-export declare function globToRe(glob: string): RegExp;
-export declare function globToReMulti(globs: string[]): RegExp;
-export {};