next 13.4.2 → 13.4.3-canary.1

package/dist/esm/shared/lib/bloom-filter/base-filter.js

@@ -1,88 +0,0 @@
-/* file : base-filter.ts
-MIT License
-
-Copyright (c) 2017-2020 Thomas Minier & Arnaud Grall
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/ import Hashing from "./hashing";
-import { getDefaultSeed } from "./utils";
-function randomInt32() {
-    if (typeof window === "undefined" && process.env.NEXT_RUNTIME === "nodejs") {
-        return require("crypto").randomBytes(4).readUInt32BE(0);
-    }
-    return crypto.getRandomValues(new Uint32Array(1))[0];
-}
-function seedrandom() {
-    return {
-        int32: randomInt32,
-        quick: randomInt32
-    };
-}
-class BaseFilter {
-    /**
-   * Get the seed used in this structure
-   */ get seed() {
-        return this._seed;
-    }
-    /**
-   * Set the seed for this structure
-   * @param  seed the new seed that will be used in this structure
-   */ set seed(seed) {
-        this._seed = seed;
-        this._rng = seedrandom();
-    }
-    /**
-   * Get a function used to draw random number
-   * @return A factory function used to draw random integer
-   */ get random() {
-        return this._rng;
-    }
-    /**
-   * Return a next random seeded int32 integer
-   * @returns
-   */ nextInt32() {
-        return this._rng.int32();
-    }
-    /**
-   * Save the current structure as a JSON
-   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    saveAsJSON() {
-        throw new Error("not-implemented");
-    }
-    /**
-   * Load an Object from a provided JSON object
-   * @param json the JSON object to load
-   * @return Return the Object loaded from the provided JSON object
-   */ // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars
-    static fromJSON(json) {
-        throw new Error("not-implemented");
-    }
-    constructor(){
-        this._seed = getDefaultSeed();
-        this._rng = seedrandom();
-        this._hashing = new Hashing();
-    }
-}
-/**
- * A base class for implementing probailistic filters
- * @author Thomas Minier
- * @author Arnaud Grall
- */ export { BaseFilter as default };
-
-//# sourceMappingURL=base-filter.js.map

package/dist/esm/shared/lib/bloom-filter/base-filter.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/base-filter.ts"],"names":["Hashing","getDefaultSeed","randomInt32","window","process","env","NEXT_RUNTIME","require","randomBytes","readUInt32BE","crypto","getRandomValues","Uint32Array","seedrandom","int32","quick","BaseFilter","seed","_seed","_rng","random","nextInt32","saveAsJSON","Error","fromJSON","json","constructor","_hashing"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBA,GAEA,OAAOA,aAAa,YAAW;AAC/B,SAASC,cAAc,QAAQ,UAAS;AAYxC,SAASC,cAAc;IACrB,IAAI,OAAOC,WAAW,eAAeC,QAAQC,GAAG,CAACC,YAAY,KAAK,UAAU;QAC1E,OAAO,AAACC,QAAQ,UACbC,WAAW,CAAC,GACZC,YAAY,CAAC;IAClB,CAAC;IACD,OAAOC,OAAOC,eAAe,CAAC,IAAIC,YAAY,GAAG,CAAC,EAAE;AACtD;AAEA,SAASC,aAAa;IACpB,OAAO;QACLC,OAAOZ;QACPa,OAAOb;IACT;AACF;AAOe,MAAec;IAW5B;;GAEC,GACD,IAAWC,OAAe;QACxB,OAAO,IAAI,CAACC,KAAK;IACnB;IAEA;;;GAGC,GACD,IAAWD,KAAKA,IAAY,EAAE;QAC5B,IAAI,CAACC,KAAK,GAAGD;QACb,IAAI,CAACE,IAAI,GAAGN;IACd;IAEA;;;GAGC,GACD,IAAWO,SAAe;QACxB,OAAO,IAAI,CAACD,IAAI;IAClB;IAEA;;;GAGC,GACD,AAAOE,YAAoB;QACzB,OAAO,IAAI,CAACF,IAAI,CAACL,KAAK;IACxB;IAEA;;GAEC,GACD,8DAA8D;IACvDQ,aAAkB;QACvB,MAAM,IAAIC,MAAM,mBAAkB;IACpC;IAEA;;;;GAIC,GACD,iGAAiG;IACjG,OAAcC,SAASC,IAAU,EAAO;QACtC,MAAM,IAAIF,MAAO,mBAAiB;IACpC;IAtDAG,aAAc;QACZ,IAAI,CAACR,KAAK,GAAGjB;QACb,IAAI,CAACkB,IAAI,GAAGN;QACZ,IAAI,CAACc,QAAQ,GAAG,IAAI3B;IACtB;AAmDF;AAjEA;;;;CAIC,GACD,SAA8BgB,wBA4D7B"}

package/dist/esm/shared/lib/bloom-filter/base64-arraybuffer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/base64-arraybuffer.ts"],"names":["chars","lookup","Uint8Array","i","length","charCodeAt","encode","arraybuffer","bytes","len","base64","substring","decode","bufferLength","p","encoded1","encoded2","encoded3","encoded4","ArrayBuffer"],"mappings":"AAAA,2FAA2F;AAE3F,MAAMA,QAAQ;AAEd,wCAAwC;AACxC,MAAMC,SAAS,OAAOC,eAAe,cAAc,EAAE,GAAG,IAAIA,WAAW,IAAI;AAC3E,IAAK,IAAIC,IAAI,GAAGA,IAAIH,MAAMI,MAAM,EAAED,IAAK;IACrCF,MAAM,CAACD,MAAMK,UAAU,CAACF,GAAG,GAAGA;AAChC;AAEA,OAAO,MAAMG,SAAS,CAACC,cAAqC;IAC1D,IAAIC,QAAQ,IAAIN,WAAWK,cACzBJ,GACAM,MAAMD,MAAMJ,MAAM,EAClBM,SAAS;IAEX,IAAKP,IAAI,GAAGA,IAAIM,KAAKN,KAAK,EAAG;QAC3BO,UAAUV,KAAK,CAACQ,KAAK,CAACL,EAAE,IAAI,EAAE;QAC9BO,UAAUV,KAAK,CAAC,AAAEQ,CAAAA,KAAK,CAACL,EAAE,GAAG,CAAA,KAAM,IAAMK,KAAK,CAACL,IAAI,EAAE,IAAI,EAAG;QAC5DO,UAAUV,KAAK,CAAC,AAAEQ,CAAAA,KAAK,CAACL,IAAI,EAAE,GAAG,EAAC,KAAM,IAAMK,KAAK,CAACL,IAAI,EAAE,IAAI,EAAG;QACjEO,UAAUV,KAAK,CAACQ,KAAK,CAACL,IAAI,EAAE,GAAG,GAAG;IACpC;IAEA,IAAIM,MAAM,MAAM,GAAG;QACjBC,SAASA,OAAOC,SAAS,CAAC,GAAGD,OAAON,MAAM,GAAG,KAAK;IACpD,OAAO,IAAIK,MAAM,MAAM,GAAG;QACxBC,SAASA,OAAOC,SAAS,CAAC,GAAGD,OAAON,MAAM,GAAG,KAAK;IACpD,CAAC;IAED,OAAOM;AACT,EAAC;AAED,OAAO,MAAME,SAAS,CAACF,SAAgC;IACrD,IAAIG,eAAeH,OAAON,MAAM,GAAG,MACjCK,MAAMC,OAAON,MAAM,EACnBD,GACAW,IAAI,GACJC,UACAC,UACAC,UACAC;IAEF,IAAIR,MAAM,CAACA,OAAON,MAAM,GAAG,EAAE,KAAK,KAAK;QACrCS;QACA,IAAIH,MAAM,CAACA,OAAON,MAAM,GAAG,EAAE,KAAK,KAAK;YACrCS;QACF,CAAC;IACH,CAAC;IAED,MAAMN,cAAc,IAAIY,YAAYN,eAClCL,QAAQ,IAAIN,WAAWK;IAEzB,IAAKJ,IAAI,GAAGA,IAAIM,KAAKN,KAAK,EAAG;QAC3BY,WAAWd,MAAM,CAACS,OAAOL,UAAU,CAACF,GAAG;QACvCa,WAAWf,MAAM,CAACS,OAAOL,UAAU,CAACF,IAAI,GAAG;QAC3Cc,WAAWhB,MAAM,CAACS,OAAOL,UAAU,CAACF,IAAI,GAAG;QAC3Ce,WAAWjB,MAAM,CAACS,OAAOL,UAAU,CAACF,IAAI,GAAG;QAE3CK,KAAK,CAACM,IAAI,GAAG,AAACC,YAAY,IAAMC,YAAY;QAC5CR,KAAK,CAACM,IAAI,GAAG,AAAEE,CAAAA,WAAW,EAAC,KAAM,IAAMC,YAAY;QACnDT,KAAK,CAACM,IAAI,GAAG,AAAEG,CAAAA,WAAW,CAAA,KAAM,IAAMC,WAAW;IACnD;IAEA,OAAOX;AACT,EAAC"}

package/dist/esm/shared/lib/bloom-filter/bit-set.js

@@ -1,129 +0,0 @@
-import { encode, decode } from "./base64-arraybuffer";
-const bitsPerWord = 8;
-class BitSet {
-    /**
-   * Returns the value of the bit at the given index
-   * @param index position of the bit, zero-indexed
-   */ has(index) {
-        const wordIndex = Math.floor(index / bitsPerWord);
-        const mask = 1 << index % bitsPerWord;
-        return (this.array[wordIndex] & mask) !== 0;
-    }
-    /**
-   * Set the bit to true
-   * @param index position of the bit, zero-indexed
-   */ add(index) {
-        const wordIndex = Math.floor(index / bitsPerWord);
-        const mask = 1 << index % bitsPerWord;
-        this.array[wordIndex] = this.array[wordIndex] | mask;
-    }
-    /**
-   * Returns the maximum true bit.
-   */ max() {
-        for(let i = this.array.length - 1; i >= 0; i--){
-            const bits = this.array[i];
-            if (bits) {
-                return BitSet.highBit(bits) + i * bitsPerWord;
-            }
-        }
-        return 0;
-    }
-    /**
-   * Returns the number of true bits.
-   */ bitCount() {
-        let result = 0;
-        for(let i = 0; i < this.array.length; i++){
-            result += BitSet.countBits(this.array[i]) // Assumes we never have bits set beyond the end
-            ;
-        }
-        return result;
-    }
-    /**
-   * Returns true if the size and contents are identical.
-   * @param other another BitSet
-   */ equals(other) {
-        if (other.size !== this.size) {
-            return false;
-        }
-        for(let i = 0; i < this.array.length; i++){
-            if (this.array[i] !== other.array[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-   * Returns a JSON-encodable object readable by {@link import}.
-   */ export() {
-        return {
-            size: this.size,
-            content: encode(this.array)
-        };
-    }
-    /**
-   * Returns an object written by {@link export}.
-   * @param data an object written by {@link export}
-   */ static import(data) {
-        if (typeof data.size !== "number") {
-            throw Error("BitSet missing size");
-        }
-        if (typeof data.content !== "string") {
-            throw Error("BitSet: missing content");
-        }
-        const result = new BitSet(data.size);
-        const buffer = decode(data.content);
-        result.array = new Uint8Array(buffer);
-        return result;
-    }
-    /**
-   * Returns the index of the maximum bit in the number, or -1 for 0
-   * @bits an unsigned 8-bit number
-   * ```js
-   * @example
-   * BitSet.highBit(0) // returns -1
-   * BitSet.highBit(5) // returns 2
-   * ```
-   */ static highBit(bits) {
-        let result = bitsPerWord - 1;
-        let mask = 1 << result;
-        while(result >= 0 && (mask & bits) !== mask){
-            mask >>>= 1;
-            result--;
-        }
-        return result;
-    }
-    /**
-   * Returns the number of true bits in the number
-   * @bits an unsigned 8-bit number
-   * @example
-   * ```js
-   * BitSet.countBits(0) // returns 0
-   * BitSet.countBits(3) // returns 2
-   * ```
-   */ static countBits(bits) {
-        let result = bits & 1;
-        while(bits !== 0){
-            bits = bits >>> 1;
-            result += bits & 1;
-        }
-        return result;
-    }
-    /**
-   * Constructor. All bits are initially set to false.
-   * @param size the number of bits that can be stored. (This is NOT required to be a multiple of 8.)
-   */ constructor(size){
-        const diff = bitsPerWord - size % bitsPerWord;
-        this.size = size + ([
-            0,
-            8
-        ].includes(diff) ? 0 : diff);
-        this.array = new Uint8Array(Math.ceil(this.size / bitsPerWord));
-    }
-}
-/**
- * A memory-efficient Boolean array. Contains just the minimal operations needed for our Bloom filter implementation.
- *
- * @author David Leppik
- */ export { BitSet as default };
-
-//# sourceMappingURL=bit-set.js.map

package/dist/esm/shared/lib/bloom-filter/bit-set.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/bit-set.ts"],"names":["encode","decode","bitsPerWord","BitSet","has","index","wordIndex","Math","floor","mask","array","add","max","i","length","bits","highBit","bitCount","result","countBits","equals","other","size","export","content","import","data","Error","buffer","Uint8Array","constructor","diff","includes","ceil"],"mappings":"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"}

package/dist/esm/shared/lib/bloom-filter/formulas.js

@@ -1,46 +0,0 @@
-/* file : formulas.ts
-MIT License
-
-Copyright (c) 2017-2020 Thomas Minier & Arnaud Grall
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/ /**
- * Various formulas used with Bloom Filters
- * @namespace Formulas
- * @private
- */ /**
- * Compute the optimal size of a Bloom Filter
- * @param  length - The length of the set used to fill the filter
- * @param  errorRate - The targeted false positive rate
- * @return The optimal size of a Bloom Filter
- * @memberof Formulas
- */ export function optimalFilterSize(length, errorRate) {
-    return Math.ceil(-(length * Math.log(errorRate) / Math.pow(Math.log(2), 2)));
-}
-/**
- * Compute the optimal number of hash functions to be used by a Bloom Filter
- * @param  size - The size of the filter
- * @param  length - The length of the set used to fill the filter
- * @return The optimal number of hash functions to be used by a Bloom Filter
- * @memberof Formulas
- */ export function optimalHashes(size, length) {
-    return Math.ceil(size / length * Math.log(2));
-}
-
-//# sourceMappingURL=formulas.js.map

package/dist/esm/shared/lib/bloom-filter/formulas.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/formulas.ts"],"names":["optimalFilterSize","length","errorRate","Math","ceil","log","pow","optimalHashes","size"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBA,GAEA;;;;CAIC,GAED;;;;;;CAMC,GACD,OAAO,SAASA,kBAAkBC,MAAc,EAAEC,SAAiB,EAAU;IAC3E,OAAOC,KAAKC,IAAI,CAAC,CAAE,CAAA,AAACH,SAASE,KAAKE,GAAG,CAACH,aAAcC,KAAKG,GAAG,CAACH,KAAKE,GAAG,CAAC,IAAI,EAAC;AAC7E,CAAC;AAED;;;;;;CAMC,GACD,OAAO,SAASE,cAAcC,IAAY,EAAEP,MAAc,EAAU;IAClE,OAAOE,KAAKC,IAAI,CAAC,AAACI,OAAOP,SAAUE,KAAKE,GAAG,CAAC;AAC9C,CAAC"}

package/dist/esm/shared/lib/bloom-filter/hashing.js

@@ -1,181 +0,0 @@
-import fnv1a from "../fnv1a";
-import { getDefaultSeed, numberToHex } from "./utils";
-class Hashing {
-    /**
-   * Apply enhanced Double Hashing to produce a n-hash
-   * @see {@link http://peterd.org/pcd-diss.pdf} s6.5.4
-   * @param  n - The indice of the hash function we want to produce
-   * @param  hashA - The result of the first hash function applied to a value.
-   * @param  hashB - The result of the second hash function applied to a value.
-   * @param  size - The size of the datastructures associated to the hash context (ex: the size of a Bloom Filter)
-   * @return The result of hash_n applied to a value.
-   * @memberof Hashing
-   * @author Thomas Minier
-   * @author Arnaud Grall
-   */ doubleHashing(n, hashA, hashB, size) {
-        return Math.abs((hashA + n * hashB + Math.floor((n ** 3 - n) / 6)) % size);
-    }
-    /**
-   * Generate a set of distinct indexes on interval [0, size) using the double hashing technique
-   * For generating efficiently distinct indexes we re-hash after detecting a cycle by changing slightly the seed.
-   * It has the effect of generating faster distinct indexes without loosing entirely the utility of the double hashing.
-   * For small number of indexes it will work perfectly. For a number close to the size, and size very large
-   * Advise: do not generate `size` indexes for a large interval. In practice, size should be equal
-   * to the number of hash functions used and is often low.
-   *
-   * @param  element  - The element to hash
-   * @param  size     - the range on which we can generate an index [0, size) = size
-   * @param  number   - The number of indexes desired
-   * @param  seed     - The seed used
-   * @return Array<number>
-   * @author Arnaud Grall
-   * @author Simon Woolf (SimonWoolf)
-   */ getDistinctIndexes(element, size, number, seed) {
-        if (seed === undefined) {
-            seed = getDefaultSeed();
-        }
-        let n = 0;
-        const indexes = new Set();
-        let hashes = this.hashTwice(element, seed);
-        // let cycle = 0
-        while(indexes.size < number){
-            const ind = hashes.first % size;
-            if (!indexes.has(ind)) {
-                indexes.add(ind);
-            }
-            hashes.first = (hashes.first + hashes.second) % size;
-            hashes.second = (hashes.second + n) % size;
-            n++;
-            if (n > size) {
-                // Enhanced double hashing stops cycles of length less than `size` in the case where
-                // size is coprime with the second hash. But you still get cycles of length `size`.
-                // So if we reach there and haven't finished, append a prime to the input and
-                // rehash.
-                seed++;
-                hashes = this.hashTwice(element, seed);
-            }
-        }
-        return [
-            ...indexes.values()
-        ];
-    }
-    /**
-   * Generate N indexes on range [0, size)
-   * It uses the double hashing technique to generate the indexes.
-   * It hash twice the value only once before generating the indexes.
-   * Warning: you can have a lot of modulo collisions.
-   * @param  element    - The element to hash
-   * @param  size       - The range on which we can generate the index, exclusive
-   * @param  hashCount  - The number of indexes we want
-   * @return An array of indexes on range [0, size)
-   */ getIndexes(element, size, hashCount, seed) {
-        if (seed === undefined) {
-            seed = getDefaultSeed();
-        }
-        const arr = [];
-        const hashes = this.hashTwice(element, seed);
-        for(let i = 0; i < hashCount; i++){
-            arr.push(this.doubleHashing(i, hashes.first, hashes.second, size));
-        }
-        return arr;
-    }
-    /**
-   * @internal
-   * Hash an element of type {@link HashableInput} into {@link Number}
-   * Can be overrided as long as you return a value of type {@link Number}
-   * Don't forget to use the seed when hashing, otherwise if some kind of randomness is in the process
-   * you may have inconsistent behaviors between 2 runs.
-   * @param element
-   * @param seed
-   * @returns A 64bits floating point {@link Number}
-   */ serialize(element, seed) {
-        if (!seed) {
-            seed = getDefaultSeed();
-        }
-        return Number(fnv1a(element, {
-            seed
-        }));
-    }
-    /**
-   * (64-bits only) Hash a value into two values (in hex or integer format)
-   * @param  value - The value to hash
-   * @param  asInt - (optional) If True, the values will be returned as an integer. Otherwise, as hexadecimal values.
-   * @param seed the seed used for hashing
-   * @return The results of the hash functions applied to the value (in hex or integer)
-   * @author Arnaud Grall & Thomas Minier
-   */ hashTwice(value, seed) {
-        if (seed === undefined) {
-            seed = getDefaultSeed();
-        }
-        return {
-            first: this.serialize(value, seed + 1),
-            second: this.serialize(value, seed + 2)
-        };
-    }
-    /**
-   * Hash twice an element into their HEX string representations
-   * @param value
-   * @param seed
-   * @returns TwoHashesTemplated<string>
-   */ hashTwiceAsString(value, seed) {
-        const { first , second  } = this.hashTwice(value, seed);
-        return {
-            first: numberToHex(first),
-            second: numberToHex(second)
-        };
-    }
-    /**
-   * (64-bits only) Same as hashTwice but return Numbers and String equivalent
-   * @param  val the value to hash
-   * @param  seed the seed to change when hashing
-   * @return TwoHashesIntAndString
-   * @author Arnaud Grall
-   */ hashTwiceIntAndString(val, seed) {
-        if (seed === undefined) {
-            seed = getDefaultSeed();
-        }
-        const one = this.hashIntAndString(val, seed + 1);
-        const two = this.hashIntAndString(val, seed + 2);
-        return {
-            int: {
-                first: one.int,
-                second: two.int
-            },
-            string: {
-                first: one.string,
-                second: two.string
-            }
-        };
-    }
-    /**
-   * Hash an item as an unsigned int
-   * @param  elem - Element to hash
-   * @param  seed - The hash seed. If its is UINT32 make sure to set the length to 32
-   * @param  length - The length of hashes (defaults to 32 bits)
-   * @return The hash value as an unsigned int
-   * @author Arnaud Grall
-   */ hashAsInt(elem, seed) {
-        if (seed === undefined) {
-            seed = getDefaultSeed();
-        }
-        return this.serialize(elem, seed);
-    }
-    /**
-   * Hash an item and return its number and HEX string representation
-   * @param  elem - Element to hash
-   * @param  seed - The hash seed. If its is UINT32 make sure to set the length to 32
-   * @param  base - The base in which the string will be returned, default: 16
-   * @param  length - The length of hashes (defaults to 32 bits)
-   * @return The item hased as an int and a string
-   * @author Arnaud Grall
-   */ hashIntAndString(elem, seed) {
-        const hash = this.hashAsInt(elem, seed);
-        return {
-            int: hash,
-            string: numberToHex(hash)
-        };
-    }
-}
-export { Hashing as default };
-
-//# sourceMappingURL=hashing.js.map

package/dist/esm/shared/lib/bloom-filter/hashing.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/hashing.ts"],"names":["fnv1a","getDefaultSeed","numberToHex","Hashing","doubleHashing","n","hashA","hashB","size","Math","abs","floor","getDistinctIndexes","element","number","seed","undefined","indexes","Set","hashes","hashTwice","ind","first","has","add","second","values","getIndexes","hashCount","arr","i","push","serialize","Number","value","hashTwiceAsString","hashTwiceIntAndString","val","one","hashIntAndString","two","int","string","hashAsInt","elem","hash"],"mappings":"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"}

package/dist/esm/shared/lib/bloom-filter/index.js

@@ -1,158 +0,0 @@
-// original source: https://github.com/Callidon/bloom-filters
-/* file : bloom-filter.ts
-MIT License
-
-Copyright (c) 2017 Thomas Minier & Arnaud Grall
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-*/ import BaseFilter from "./base-filter";
-import BitSet from "./bit-set";
-import { optimalFilterSize, optimalHashes } from "./formulas";
-/**
- * A Bloom filter is a space-efficient probabilistic data structure, conceived by Burton Howard Bloom in 1970,
- * that is used to test whether an element is a member of a set. False positive matches are possible, but false negatives are not.
- *
- * Reference: Bloom, B. H. (1970). Space/time trade-offs in hash coding with allowable errors. Communications of the ACM, 13(7), 422-426.
- * @see {@link http://crystal.uta.edu/~mcguigan/cse6350/papers/Bloom.pdf} for more details about classic Bloom Filters.
- * @author Thomas Minier
- * @author Arnaud Grall
- */ export class BloomFilter extends BaseFilter {
-    /**
-   * Create an optimal bloom filter providing the maximum of elements stored and the error rate desired
-   * @param  nbItems      - The maximum number of item to store
-   * @param  errorRate  - The error rate desired for a maximum of items inserted
-   * @return A new {@link BloomFilter}
-   */ static create(nbItems, errorRate) {
-        const size = optimalFilterSize(nbItems, errorRate);
-        const hashes = optimalHashes(size, nbItems);
-        return new this(size, hashes);
-    }
-    /**
-   * Build a new Bloom Filter from an existing iterable with a fixed error rate
-   * @param items - The iterable used to populate the filter
-   * @param errorRate - The error rate, i.e. 'false positive' rate, targeted by the filter
-   * @param seed - The random number seed (optional)
-   * @return A new Bloom Filter filled with the iterable's elements
-   * @example
-   * ```js
-   * // create a filter with a false positive rate of 0.1
-   * const filter = BloomFilter.from(['alice', 'bob', 'carl'], 0.1);
-   * ```
-   */ static from(items, errorRate, seed) {
-        const array = Array.from(items);
-        const filter = BloomFilter.create(array.length, errorRate);
-        if (typeof seed === "number") {
-            filter.seed = seed;
-        }
-        array.forEach((element)=>filter.add(element));
-        return filter;
-    }
-    /**
-   * Get the optimal size of the filter
-   * @return The size of the filter
-   */ get size() {
-        return this._size;
-    }
-    /**
-   * Get the number of bits currently set in the filter
-   * @return The filter length
-   */ get length() {
-        return this._filter.bitCount();
-    }
-    /**
-   * Add an element to the filter
-   * @param element - The element to add
-   * @example
-   * ```js
-   * const filter = new BloomFilter(15, 0.1);
-   * filter.add('foo');
-   * ```
-   */ add(element) {
-        const indexes = this._hashing.getIndexes(element, this._size, this._nbHashes, this.seed);
-        for(let i = 0; i < indexes.length; i++){
-            this._filter.add(indexes[i]);
-        }
-    }
-    /**
-   * Test an element for membership
-   * @param element - The element to look for in the filter
-   * @return False if the element is definitively not in the filter, True is the element might be in the filter
-   * @example
-   * ```js
-   * const filter = new BloomFilter(15, 0.1);
-   * filter.add('foo');
-   * console.log(filter.has('foo')); // output: true
-   * console.log(filter.has('bar')); // output: false
-   * ```
-   */ has(element) {
-        const indexes = this._hashing.getIndexes(element, this._size, this._nbHashes, this.seed);
-        for(let i = 0; i < indexes.length; i++){
-            if (!this._filter.has(indexes[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-   * Get the current false positive rate (or error rate) of the filter
-   * @return The current false positive rate of the filter
-   * @example
-   * ```js
-   * const filter = new BloomFilter(15, 0.1);
-   * console.log(filter.rate()); // output: something around 0.1
-   * ```
-   */ rate() {
-        return Math.pow(1 - Math.exp(-this.length / this._size), this._nbHashes);
-    }
-    /**
-   * Check if another Bloom Filter is equal to this one
-   * @param  other - The filter to compare to this one
-   * @return True if they are equal, false otherwise
-   */ equals(other) {
-        if (this._size !== other._size || this._nbHashes !== other._nbHashes) {
-            return false;
-        }
-        return this._filter.equals(other._filter);
-    }
-    export() {
-        return {
-            bitset: this._filter.export(),
-            hashes: this._nbHashes,
-            size: this._size
-        };
-    }
-    import(data) {
-        this._filter = BitSet.import(data.bitset);
-    }
-    /**
-   * Constructor
-   * @param size - The number of cells
-   * @param nbHashes - The number of hash functions used
-   */ constructor(size, nbHashes){
-        super();
-        if (nbHashes < 1) {
-            throw new Error("A BloomFilter cannot uses less than one hash function, while you tried to use " + nbHashes + ".");
-        }
-        this._size = size;
-        this._nbHashes = nbHashes;
-        this._filter = new BitSet(size);
-    }
-}
-
-//# sourceMappingURL=index.js.map

package/dist/esm/shared/lib/bloom-filter/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/index.ts"],"names":["BaseFilter","BitSet","optimalFilterSize","optimalHashes","BloomFilter","create","nbItems","errorRate","size","hashes","from","items","seed","array","Array","filter","length","forEach","element","add","_size","_filter","bitCount","indexes","_hashing","getIndexes","_nbHashes","i","has","rate","Math","pow","exp","equals","other","export","bitset","import","data","constructor","nbHashes","Error"],"mappings":"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"}