next 13.4.2 → 13.4.3-canary.1

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

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return Hashing;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _fnv1a = /*#__PURE__*/ _interop_require_default._(require("../fnv1a"));
-const _utils = require("./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 = (0, _utils.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 = (0, _utils.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 = (0, _utils.getDefaultSeed)();
-        }
-        return Number((0, _fnv1a.default)(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 = (0, _utils.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: (0, _utils.numberToHex)(first),
-            second: (0, _utils.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 = (0, _utils.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 = (0, _utils.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: (0, _utils.numberToHex)(hash)
-        };
-    }
-}
-
-//# sourceMappingURL=hashing.js.map

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

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

package/dist/shared/lib/bloom-filter/index.d.ts

@@ -1,101 +0,0 @@
-import BaseFilter from './base-filter';
-import BitSet from './bit-set';
-import { HashableInput } from './hashing';
-/**
- * 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 declare class BloomFilter extends BaseFilter {
-    _size: number;
-    _nbHashes: number;
-    _filter: BitSet;
-    /**
-     * Constructor
-     * @param size - The number of cells
-     * @param nbHashes - The number of hash functions used
-     */
-    constructor(size: number, nbHashes: number);
-    /**
-     * 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: number, errorRate: number): BloomFilter;
-    /**
-     * 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: Iterable<HashableInput>, errorRate: number, seed?: number): BloomFilter;
-    /**
-     * Get the optimal size of the filter
-     * @return The size of the filter
-     */
-    get size(): number;
-    /**
-     * Get the number of bits currently set in the filter
-     * @return The filter length
-     */
-    get length(): number;
-    /**
-     * 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: HashableInput): void;
-    /**
-     * 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: HashableInput): boolean;
-    /**
-     * 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(): number;
-    /**
-     * 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: BloomFilter): boolean;
-    export(): {
-        bitset: {
-            size: number;
-            content: string;
-        };
-        hashes: number;
-        size: number;
-    };
-    import(data: ReturnType<typeof this.export>): void;
-}

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

@@ -1,161 +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.
-*/ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "BloomFilter", {
-    enumerable: true,
-    get: function() {
-        return BloomFilter;
-    }
-});
-const _interop_require_default = require("@swc/helpers/_/_interop_require_default");
-const _basefilter = /*#__PURE__*/ _interop_require_default._(require("./base-filter"));
-const _bitset = /*#__PURE__*/ _interop_require_default._(require("./bit-set"));
-const _formulas = require("./formulas");
-class BloomFilter extends _basefilter.default {
-    /**
-   * 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 = (0, _formulas.optimalFilterSize)(nbItems, errorRate);
-        const hashes = (0, _formulas.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.default.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.default(size);
-    }
-}
-
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/index.ts"],"names":["BloomFilter","BaseFilter","create","nbItems","errorRate","size","optimalFilterSize","hashes","optimalHashes","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","BitSet","constructor","nbHashes","Error"],"mappings":"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"}

package/dist/shared/lib/bloom-filter/utils.d.ts

@@ -1,56 +0,0 @@
-/// <reference types="node" />
-/**
- * Utilitaries functions
- * @namespace Utils
- * @private
- */
-/**
- * @typedef {TwoHashes} Two hashes of the same value, as computed by {@link hashTwice}.
- * @property {number} first - The result of the first hashing function applied to a value
- * @property {number} second - The result of the second hashing function applied to a value
- * @memberof Utils
- */
-export interface TwoHashes {
-    first: number;
-    second: number;
-}
-/**
- * Templated TwoHashes type
- */
-export interface TwoHashesTemplated<T> {
-    first: T;
-    second: T;
-}
-/**
- * TwoHashes type in number and int format
- */
-export interface TwoHashesIntAndString {
-    int: TwoHashesTemplated<number>;
-    string: TwoHashesTemplated<string>;
-}
-/**
- * Data type of an hashable value, must be string, ArrayBuffer or Buffer.
- */
-export declare type HashableInput = string | ArrayBuffer | Buffer;
-/**
- * Return a number to its Hex format by padding zeroes if length mod 4 != 0
- * @param elem the element to transform in HEX
- * @returns the HEX number padded of zeroes
- */
-export declare function numberToHex(elem: number): string;
-/**
- * Generate a random int between two bounds (included)
- * @param min - The lower bound
- * @param max - The upper bound
- * @param random - Function used to generate random floats
- * @return A random int bewteen lower and upper bound (included)
- * @memberof Utils
- * @author Thomas Minier
- */
-export declare function randomInt(min: number, max: number, random?: () => number): number;
-/**
- * Return the default seed used in the package
- * @return A seed as a floating point number
- * @author Arnaud Grall
- */
-export declare function getDefaultSeed(): number;

package/dist/shared/lib/bloom-filter/utils.js

@@ -1,78 +0,0 @@
-/* file : utils.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.
-*/ /**
- * Utilitaries functions
- * @namespace Utils
- * @private
- */ /* JSDOC typedef */ /**
- * @typedef {TwoHashes} Two hashes of the same value, as computed by {@link hashTwice}.
- * @property {number} first - The result of the first hashing function applied to a value
- * @property {number} second - The result of the second hashing function applied to a value
- * @memberof Utils
- */ "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    numberToHex: null,
-    randomInt: null,
-    getDefaultSeed: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    numberToHex: function() {
-        return numberToHex;
-    },
-    randomInt: function() {
-        return randomInt;
-    },
-    getDefaultSeed: function() {
-        return getDefaultSeed;
-    }
-});
-function numberToHex(elem) {
-    let e = Number(elem).toString(16);
-    if (e.length % 4 !== 0) {
-        e = "0".repeat(4 - e.length % 4) + e;
-    }
-    return e;
-}
-function randomInt(min, max, random) {
-    if (random === undefined) {
-        random = Math.random;
-    }
-    min = Math.ceil(min);
-    max = Math.floor(max);
-    const rn = random();
-    return Math.floor(rn * (max - min + 1)) + min;
-}
-function getDefaultSeed() {
-    return 0x1234567890;
-}
-
-//# sourceMappingURL=utils.js.map

package/dist/shared/lib/bloom-filter/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/shared/lib/bloom-filter/utils.ts"],"names":["numberToHex","randomInt","getDefaultSeed","elem","e","Number","toString","length","repeat","min","max","random","undefined","Math","ceil","floor","rn"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;AAsBA,GAEA;;;;CAIC,GAED,iBAAiB,GACjB;;;;;CAKC;;;;;;;;;;;;;;;;IAgCeA,WAAW;eAAXA;;IAiBAC,SAAS;eAATA;;IAmBAC,cAAc;eAAdA;;;AApCT,SAASF,YAAYG,IAAY,EAAU;IAChD,IAAIC,IAAIC,OAAOF,MAAMG,QAAQ,CAAC;IAC9B,IAAIF,EAAEG,MAAM,GAAG,MAAM,GAAG;QACtBH,IAAI,IAAII,MAAM,CAAC,IAAKJ,EAAEG,MAAM,GAAG,KAAMH;IACvC,CAAC;IACD,OAAOA;AACT;AAWO,SAASH,UACdQ,GAAW,EACXC,GAAW,EACXC,MAAqB,EACb;IACR,IAAIA,WAAWC,WAAW;QACxBD,SAASE,KAAKF,MAAM;IACtB,CAAC;IACDF,MAAMI,KAAKC,IAAI,CAACL;IAChBC,MAAMG,KAAKE,KAAK,CAACL;IACjB,MAAMM,KAAKL;IACX,OAAOE,KAAKE,KAAK,CAACC,KAAMN,CAAAA,MAAMD,MAAM,CAAA,KAAMA;AAC5C;AAOO,SAASP,iBAAyB;IACvC,OAAO;AACT"}