rx-player 4.0.0-dev.2023121900 → 4.0.0-rc.2

package/dist/_esm5.processed/utils/assert_unreachable.js

@@ -1,43 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { AssertionError } from "../errors";
-/**
- * TypeScript hack to make sure a code path is never taken.
- *
- * This can for example be used to ensure that a switch statement handle all
- * possible cases by adding a default clause calling assertUnreachable with
- * an argument (it doesn't matter which one).
- *
- * @example
- * function parseBinary(str : "0" | "1") : number {
- *   switch (str) {
- *     case "0:
- *       return 0;
- *     case "1":
- *       return 1;
- *     default:
- *       // branch never taken. If it can be, TypeScript will yell at us because
- *       // its argument (here, `str`) is not of the right type.
- *       assertUnreachable(str);
- *   }
- * }
- * @param {*} _
- * @throws AssertionError - Throw an AssertionError when called. If we're
- * sufficiently strict with how we use TypeScript, this should never happen.
- */
-export default function assertUnreachable(_) {
-    throw new AssertionError("Unreachable path taken");
-}

package/dist/_esm5.processed/utils/base64.d.ts

@@ -1,14 +0,0 @@
-/**
- * Convert an array of bytes into a base64 string.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export declare function bytesToBase64(bytes: number[] | Uint8Array): string;
-/**
- * Convert a base64 string into the corresponding Uint8Array containing its
- * corresponding binary data.
- * /!\ Can throw if an invalid base64 string was given.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export declare function base64ToBytes(str: string): Uint8Array;

package/dist/_esm5.processed/utils/base64.js

@@ -1,147 +0,0 @@
-/* eslint-disable */
-/*
-MIT License
-Copyright (c) 2020 Egor Nepomnyaschih
-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 log from "../log";
-/*
-// This constant can also be computed with the following algorithm:
-const base64abc = [],
-  A = "A".charCodeAt(0),
-  a = "a".charCodeAt(0),
-  n = "0".charCodeAt(0);
-for (let i = 0; i < 26; ++i) {
-  base64abc.push(String.fromCharCode(A + i));
-}
-for (let i = 0; i < 26; ++i) {
-  base64abc.push(String.fromCharCode(a + i));
-}
-for (let i = 0; i < 10; ++i) {
-  base64abc.push(String.fromCharCode(n + i));
-}
-base64abc.push("+");
-base64abc.push("/");
- */
-var base64abc = [
-    "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
-    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
-    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
-    "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
-    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/",
-];
-/*
-// This constant can also be computed with the following algorithm:
-const l = 256, base64codes = new Uint8Array(l);
-for (let i = 0; i < l; ++i) {
-  base64codes[i] = 255; // invalid character
-}
-base64abc.forEach((char, index) => {
-  base64codes[char.charCodeAt(0)] = index;
-});
-base64codes["=".charCodeAt(0)] = 0; // ignored anyway, so we just need to prevent an error
- */
-var base64codes = [
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63,
-    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, 255, 0, 255, 255,
-    255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255,
-    255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
-];
-/**
- * Obtain the value corresponding to a base64 char code.
- * /!\ Can throw if the char code given is invalid.
- * @param {number} charCode
- * @returns {number}
- */
-function getBase64Code(charCode) {
-    if (charCode >= base64codes.length) {
-        throw new Error("Unable to parse base64 string.");
-    }
-    var code = base64codes[charCode];
-    if (code === 255) {
-        throw new Error("Unable to parse base64 string.");
-    }
-    return code;
-}
-/**
- * Convert an array of bytes into a base64 string.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export function bytesToBase64(bytes) {
-    var result = "";
-    var i;
-    var length = bytes.length;
-    for (i = 2; i < length; i += 3) {
-        result += base64abc[bytes[i - 2] >> 2];
-        result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
-        result += base64abc[((bytes[i - 1] & 0x0F) << 2) | (bytes[i] >> 6)];
-        result += base64abc[bytes[i] & 0x3F];
-    }
-    if (i === length + 1) { // 1 octet yet to write
-        result += base64abc[bytes[i - 2] >> 2];
-        result += base64abc[(bytes[i - 2] & 0x03) << 4];
-        result += "==";
-    }
-    if (i === length) { // 2 octets yet to write
-        result += base64abc[bytes[i - 2] >> 2];
-        result += base64abc[((bytes[i - 2] & 0x03) << 4) | (bytes[i - 1] >> 4)];
-        result += base64abc[(bytes[i - 1] & 0x0F) << 2];
-        result += "=";
-    }
-    return result;
-}
-/**
- * Convert a base64 string into the corresponding Uint8Array containing its
- * corresponding binary data.
- * /!\ Can throw if an invalid base64 string was given.
- * @param {Array.<number>|Uint8Array} bytes
- * @returns {string}
- */
-export function base64ToBytes(str) {
-    var paddingNeeded = str.length % 4;
-    var paddedStr = str;
-    if (paddingNeeded !== 0) {
-        log.warn("base64ToBytes: base64 given miss padding");
-        paddedStr += paddingNeeded === 3 ? "=" :
-            paddingNeeded === 2 ? "==" :
-                "==="; // invalid, but we will catch it
-    }
-    var index = paddedStr.indexOf("=");
-    if (index !== -1 && index < paddedStr.length - 2) {
-        throw new Error("Unable to parse base64 string.");
-    }
-    var missingOctets = paddedStr.endsWith("==") ? 2 :
-        paddedStr.endsWith("=") ? 1 : 0;
-    var n = paddedStr.length;
-    var result = new Uint8Array((n / 4) * 3);
-    var buffer;
-    for (var i = 0, j = 0; i < n; i += 4, j += 3) {
-        buffer = getBase64Code(paddedStr.charCodeAt(i)) << 18 |
-            getBase64Code(paddedStr.charCodeAt(i + 1)) << 12 |
-            getBase64Code(paddedStr.charCodeAt(i + 2)) << 6 |
-            getBase64Code(paddedStr.charCodeAt(i + 3));
-        result[j] = buffer >> 16;
-        result[j + 1] = (buffer >> 8) & 0xFF;
-        result[j + 2] = buffer & 0xFF;
-    }
-    return result.subarray(0, result.length - missingOctets);
-}

package/dist/_esm5.processed/utils/byte_parsing.d.ts

@@ -1,123 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Returns a Uint8Array from the arguments given, in order:
- *   - if the next argument given is a number N set the N next bytes to 0.
- *   - else set the next bytes to the argument given.
- * @param {...(Number|Uint8Array)} args
- * @returns {Uint8Array}
- */
-declare function concat(...args: Array<Uint8Array | number[] | number>): Uint8Array;
-/**
- * Translate groups of 2 big-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function be2toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate groups of 3 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function be3toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate groups of 4 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function be4toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate groups of 8 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function be8toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding big-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-declare function itobe2(num: number): Uint8Array;
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding big-endian
- * bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-declare function itobe4(num: number): Uint8Array;
-/**
- * Translate Integer to a Uint8Array of length 8 of the corresponding big-endian
- * bytes.
- * /!\ If the top-most bytes are set, this might go over MAX_SAFE_INTEGER, thus
- * leading to a "bad" value.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-declare function itobe8(num: number): Uint8Array;
-/**
- * Translate groups of 2 little-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function le2toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate groups of 4 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function le4toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate groups of 8 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-declare function le8toi(bytes: Uint8Array, offset: number): number;
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-declare function itole2(num: number): Uint8Array;
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding
- * little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-declare function itole4(num: number): Uint8Array;
-/**
- * Check if an ArrayBuffer is equal to the bytes given.
- * @param {ArrayBuffer} buffer
- * @param {Uint8Array} bytes
- * @returns {Boolean}
- */
-declare function isABEqualBytes(buffer: ArrayBuffer, bytes: Uint8Array): boolean;
-/**
- * Convert any BufferSource-typed structure into the corresponding Uint8Array.
- * @param {BufferSource} input
- * @returns {Uint8Array}
- */
-declare function toUint8Array(input: BufferSource): Uint8Array;
-export { concat, be2toi, be3toi, be4toi, be8toi, le2toi, le4toi, le8toi, itobe2, itobe4, itobe8, itole2, itole4, isABEqualBytes, toUint8Array, };

package/dist/_esm5.processed/utils/byte_parsing.js

@@ -1,231 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Returns a Uint8Array from the arguments given, in order:
- *   - if the next argument given is a number N set the N next bytes to 0.
- *   - else set the next bytes to the argument given.
- * @param {...(Number|Uint8Array)} args
- * @returns {Uint8Array}
- */
-function concat() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var l = args.length;
-    var i = -1;
-    var len = 0;
-    var arg;
-    while (++i < l) {
-        arg = args[i];
-        len += (typeof arg === "number") ? arg : arg.length;
-    }
-    var arr = new Uint8Array(len);
-    var offset = 0;
-    i = -1;
-    while (++i < l) {
-        arg = args[i];
-        if (typeof arg === "number") {
-            offset += arg;
-        }
-        else if (arg.length > 0) {
-            arr.set(arg, offset);
-            offset += arg.length;
-        }
-    }
-    return arr;
-}
-/**
- * Translate groups of 2 big-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be2toi(bytes, offset) {
-    return ((bytes[offset + 0] << 8) +
-        (bytes[offset + 1] << 0));
-}
-/**
- * Translate groups of 3 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be3toi(bytes, offset) {
-    return ((bytes[offset + 0] * 0x0010000) +
-        (bytes[offset + 1] * 0x0000100) +
-        (bytes[offset + 2]));
-}
-/**
- * Translate groups of 4 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be4toi(bytes, offset) {
-    return ((bytes[offset + 0] * 0x1000000) +
-        (bytes[offset + 1] * 0x0010000) +
-        (bytes[offset + 2] * 0x0000100) +
-        (bytes[offset + 3]));
-}
-/**
- * Translate groups of 8 big-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function be8toi(bytes, offset) {
-    return (((bytes[offset + 0] * 0x1000000) +
-        (bytes[offset + 1] * 0x0010000) +
-        (bytes[offset + 2] * 0x0000100) +
-        (bytes[offset + 3])) * 0x100000000 +
-        (bytes[offset + 4] * 0x1000000) +
-        (bytes[offset + 5] * 0x0010000) +
-        (bytes[offset + 6] * 0x0000100) +
-        (bytes[offset + 7]));
-}
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding big-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe2(num) {
-    return new Uint8Array([(num >>> 8) & 0xFF,
-        (num) & 0xFF]);
-}
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding big-endian
- * bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe4(num) {
-    return new Uint8Array([(num >>> 24) & 0xFF,
-        (num >>> 16) & 0xFF,
-        (num >>> 8) & 0xFF,
-        (num) & 0xFF]);
-}
-/**
- * Translate Integer to a Uint8Array of length 8 of the corresponding big-endian
- * bytes.
- * /!\ If the top-most bytes are set, this might go over MAX_SAFE_INTEGER, thus
- * leading to a "bad" value.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itobe8(num) {
-    var l = (num % 0x100000000);
-    var h = (num - l) / 0x100000000;
-    return new Uint8Array([(h >>> 24) & 0xFF,
-        (h >>> 16) & 0xFF,
-        (h >>> 8) & 0xFF,
-        (h) & 0xFF,
-        (l >>> 24) & 0xFF,
-        (l >>> 16) & 0xFF,
-        (l >>> 8) & 0xFF,
-        (l) & 0xFF]);
-}
-/**
- * Translate groups of 2 little-endian bytes to Integer (from 0 up to 65535).
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le2toi(bytes, offset) {
-    return ((bytes[offset + 0] << 0) +
-        (bytes[offset + 1] << 8));
-}
-/**
- * Translate groups of 4 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le4toi(bytes, offset) {
-    return ((bytes[offset + 0]) +
-        (bytes[offset + 1] * 0x0000100) +
-        (bytes[offset + 2] * 0x0010000) +
-        (bytes[offset + 3] * 0x1000000));
-}
-/**
- * Translate groups of 8 little-endian bytes to Integer.
- * @param {Uint8Array} bytes
- * @param {Number} offset - The offset (from the start of the given array)
- * @returns {Number}
- */
-function le8toi(bytes, offset) {
-    return (bytes[offset + 0]) +
-        (bytes[offset + 1] * 0x0000100) +
-        (bytes[offset + 2] * 0x0010000) +
-        (bytes[offset + 3] * 0x1000000) +
-        ((bytes[offset + 4]) +
-            (bytes[offset + 5] * 0x0000100) +
-            (bytes[offset + 6] * 0x0010000) +
-            (bytes[offset + 7] * 0x1000000)) * 0x100000000;
-}
-/**
- * Translate Integer (from 0 up to 65535) to a Uint8Array of length 2 of
- * the corresponding little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itole2(num) {
-    return new Uint8Array([(num) & 0xFF,
-        (num >>> 8) & 0xFF]);
-}
-/**
- * Translate Integer to a Uint8Array of length 4 of the corresponding
- * little-endian bytes.
- * @param {Number} num
- * @returns {Uint8Array}
- */
-function itole4(num) {
-    return new Uint8Array([(num) & 0xFF,
-        (num >>> 8) & 0xFF,
-        (num >>> 16) & 0xFF,
-        (num >>> 24) & 0xFF]);
-}
-/**
- * Check if an ArrayBuffer is equal to the bytes given.
- * @param {ArrayBuffer} buffer
- * @param {Uint8Array} bytes
- * @returns {Boolean}
- */
-function isABEqualBytes(buffer, bytes) {
-    var view = new DataView(buffer);
-    var len = view.byteLength;
-    if (len !== bytes.length) {
-        return false;
-    }
-    for (var i = 0; i < len; i++) {
-        if (view.getUint8(i) !== bytes[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * Convert any BufferSource-typed structure into the corresponding Uint8Array.
- * @param {BufferSource} input
- * @returns {Uint8Array}
- */
-function toUint8Array(input) {
-    return input instanceof Uint8Array ? input :
-        input instanceof ArrayBuffer ? new Uint8Array(input) :
-            new Uint8Array(input.buffer);
-}
-export { concat, be2toi, be3toi, be4toi, be8toi, le2toi, le4toi, le8toi, itobe2, itobe4, itobe8, itole2, itole4, isABEqualBytes, toUint8Array, };

package/dist/_esm5.processed/utils/cancellable_sleep.d.ts

@@ -1,30 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { CancellationSignal } from "./task_canceller";
-/**
- * Wait the given `delay`, resolving the Promise when finished.
- *
- * The `cancellationSignal` given allows to cancel that timeout. In the case it
- * is triggered before the timeout ended, this function will reject the
- * corresponding `CancellationError` through the returned Promise.
- *
- * @param {number} delay - Delay to wait, in milliseconds
- * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
- * the timeout.
- * @returns {Promise} - Resolve on timeout completion, rejects on timeout
- * cancellation with the corresponding `CancellationError`.
- */
-export default function cancellableSleep(delay: number, cancellationSignal: CancellationSignal): Promise<void>;

package/dist/_esm5.processed/utils/cancellable_sleep.js

@@ -1,35 +0,0 @@
-/**
- * Copyright 2015 CANAL+ Group
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import createCancellablePromise from "./create_cancellable_promise";
-/**
- * Wait the given `delay`, resolving the Promise when finished.
- *
- * The `cancellationSignal` given allows to cancel that timeout. In the case it
- * is triggered before the timeout ended, this function will reject the
- * corresponding `CancellationError` through the returned Promise.
- *
- * @param {number} delay - Delay to wait, in milliseconds
- * @param {Object} cancellationSignal - `CancellationSignal` allowing to abort
- * the timeout.
- * @returns {Promise} - Resolve on timeout completion, rejects on timeout
- * cancellation with the corresponding `CancellationError`.
- */
-export default function cancellableSleep(delay, cancellationSignal) {
-    return createCancellablePromise(cancellationSignal, function (res) {
-        var timeout = setTimeout(function () { return res(); }, delay);
-        return function () { return clearTimeout(timeout); };
-    });
-}

package/dist/_esm5.processed/utils/create_cancellable_promise.d.ts

@@ -1,26 +0,0 @@
-import { CancellationSignal } from "./task_canceller";
-/**
- * Returns a Promise linked to a `CancellationSignal`, which will reject the
- * corresponding `CancellationError` if that signal emits before the wanted
- * task finishes (either on success or on error).
- *
- * The given callback mimicks the Promise interface with the added possibility
- * of returning a callback which will be called when and if the task is
- * cancelled before being either resolved or rejected.
- * In that case, that logic will be called just before the Promise is rejected
- * with the corresponding `CancellationError`.
- * The point of this callback is to implement aborting logic, such as for
- * example aborting a request.
- *
- * @param {Object} cancellationSignal - The `CancellationSignal` the returned
- * Promise will be linked to.
- * @param {Function} cb - The function implementing the cancellable Promise. Its
- * arguments follow Promise's semantics but it can also return a function which
- * will be called when and if `cancellationSignal` emits before either arguments
- * are called.
- * @returns {Promise} - The created Promise, which will resolve when and if the
- * first argument to `cb` is called first and reject either if the second
- * argument to `cb` is called first or if the given `CancellationSignal` emits
- * before either of the two previous conditions.
- */
-export default function createCancellablePromise<T>(cancellationSignal: CancellationSignal, cb: (resolve: (val: T) => void, reject: (err: unknown) => void) => (() => void) | void): Promise<T>;