rx-player 4.0.0-beta.2 → 4.0.0-beta.3

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,12 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../log";
-import assert from "./assert";
-var hasTextDecoder = typeof window === "object" &&
-    typeof window.TextDecoder === "function";
-var hasTextEncoder = typeof window === "object" &&
-    typeof window.TextEncoder === "function";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNullTerminatedString = exports.guidToUuid = exports.beUtf16ToStr = exports.strToBeUtf16 = exports.utf16LEToStr = exports.strToUtf16LE = exports.utf8ToStr = exports.strToUtf8 = exports.hexToBytes = exports.bytesToHex = void 0;
+const global_scope_1 = require("../compat/global_scope");
+const log_1 = require("../log");
+const assert_1 = require("./assert");
+const hasTextDecoder = typeof global_scope_1.default === "object" &&
+    typeof global_scope_1.default.TextDecoder === "function";
+const hasTextEncoder = typeof global_scope_1.default === "object" &&
+    typeof global_scope_1.default.TextEncoder === "function";
 /**
  * Convert a string to an Uint8Array containing the corresponding UTF-16 code
  * units in little-endian.
@@ -26,15 +30,16 @@ var hasTextEncoder = typeof window === "object" &&
  * @returns {Uint8Array}
  */
 function strToUtf16LE(str) {
-    var buffer = new ArrayBuffer(str.length * 2);
-    var res = new Uint8Array(buffer);
-    for (var i = 0; i < res.length; i += 2) {
-        var value = str.charCodeAt(i / 2);
+    const buffer = new ArrayBuffer(str.length * 2);
+    const res = new Uint8Array(buffer);
+    for (let i = 0; i < res.length; i += 2) {
+        const value = str.charCodeAt(i / 2);
         res[i] = value & 0xFF;
         res[i + 1] = value >> 8 & 0xFF;
     }
     return res;
 }
+exports.strToUtf16LE = strToUtf16LE;
 /**
  * Convert a string to an Uint8Array containing the corresponding UTF-16 code
  * units in little-endian.
@@ -42,15 +47,16 @@ function strToUtf16LE(str) {
  * @returns {Uint8Array}
  */
 function strToBeUtf16(str) {
-    var buffer = new ArrayBuffer(str.length * 2);
-    var res = new Uint8Array(buffer);
-    for (var i = 0; i < res.length; i += 2) {
-        var value = str.charCodeAt(i / 2);
+    const buffer = new ArrayBuffer(str.length * 2);
+    const res = new Uint8Array(buffer);
+    for (let i = 0; i < res.length; i += 2) {
+        const value = str.charCodeAt(i / 2);
         res[i + 1] = value & 0xFF;
         res[i] = value >> 8 & 0xFF;
     }
     return res;
 }
+exports.strToBeUtf16 = strToBeUtf16;
 /**
  * Construct string from the little-endian UTF-16 code units given.
  * @param {Uint8Array} bytes
@@ -60,21 +66,22 @@ function utf16LEToStr(bytes) {
     if (hasTextDecoder) {
         try {
             // instanciation throws if the encoding is unsupported
-            var decoder = new TextDecoder("utf-16le");
+            const decoder = new TextDecoder("utf-16le");
             return decoder.decode(bytes);
         }
         catch (e) {
-            var err = e instanceof Error ? e : "";
-            log.warn("Utils: could not use TextDecoder to parse UTF-16LE, " +
+            const err = e instanceof Error ? e : "";
+            log_1.default.warn("Utils: could not use TextDecoder to parse UTF-16LE, " +
                 "fallbacking to another implementation", err);
         }
     }
-    var str = "";
-    for (var i = 0; i < bytes.length; i += 2) {
+    let str = "";
+    for (let i = 0; i < bytes.length; i += 2) {
         str += String.fromCharCode((bytes[i + 1] << 8) + bytes[i]);
     }
     return str;
 }
+exports.utf16LEToStr = utf16LEToStr;
 /**
  * Construct string from the little-endian UTF-16 code units given.
  * @param {Uint8Array} bytes
@@ -84,21 +91,22 @@ function beUtf16ToStr(bytes) {
     if (hasTextDecoder) {
         try {
             // instanciation throws if the encoding is unsupported
-            var decoder = new TextDecoder("utf-16be");
+            const decoder = new TextDecoder("utf-16be");
             return decoder.decode(bytes);
         }
         catch (e) {
-            var err = e instanceof Error ? e : "";
-            log.warn("Utils: could not use TextDecoder to parse UTF-16BE, " +
+            const err = e instanceof Error ? e : "";
+            log_1.default.warn("Utils: could not use TextDecoder to parse UTF-16BE, " +
                 "fallbacking to another implementation", err);
         }
     }
-    var str = "";
-    for (var i = 0; i < bytes.length; i += 2) {
+    let str = "";
+    for (let i = 0; i < bytes.length; i += 2) {
         str += String.fromCharCode((bytes[i] << 8) + bytes[i + 1]);
     }
     return str;
 }
+exports.beUtf16ToStr = beUtf16ToStr;
 /**
  * Convert a string to an Uint8Array containing the corresponding UTF-8 code
  * units.
@@ -108,12 +116,12 @@ function beUtf16ToStr(bytes) {
 function strToUtf8(str) {
     if (hasTextEncoder) {
         try {
-            var encoder = new TextEncoder();
+            const encoder = new TextEncoder();
             return encoder.encode(str);
         }
         catch (e) {
-            var err = e instanceof Error ? e : "";
-            log.warn("Utils: could not use TextEncoder to encode string into UTF-8, " +
+            const err = e instanceof Error ? e : "";
+            log_1.default.warn("Utils: could not use TextEncoder to encode string into UTF-8, " +
                 "fallbacking to another implementation", err);
         }
     }
@@ -145,8 +153,8 @@ function strToUtf8(str) {
     // By iterating on the resulting string, we will then be able to generate a
     // Uint8Array containing the UTF-8 representation of that original string, by
     // just calling the charCodeAt API on it.
-    var utf8Str;
-    var pcStr = encodeURIComponent(str);
+    let utf8Str;
+    const pcStr = encodeURIComponent(str);
     // As "unescape" is a deprecated function we want to declare a fallback in the
     // case a browser decide to not implement it.
     if (typeof unescape === "function") {
@@ -155,11 +163,11 @@ function strToUtf8(str) {
     else {
         // Let's implement a simple unescape function (got to admit it was for the challenge)
         // http://ecma-international.org/ecma-262/9.0/#sec-unescape-string
-        var isHexChar = /[0-9a-fA-F]/;
-        var pcStrLen = pcStr.length;
+        const isHexChar = /[0-9a-fA-F]/;
+        const pcStrLen = pcStr.length;
         utf8Str = "";
-        for (var i = 0; i < pcStr.length; i++) {
-            var wasPercentEncoded = false;
+        for (let i = 0; i < pcStr.length; i++) {
+            let wasPercentEncoded = false;
             if (pcStr[i] === "%") {
                 if (i <= pcStrLen - 6 &&
                     pcStr[i + 1] === "u" &&
@@ -167,7 +175,7 @@ function strToUtf8(str) {
                     isHexChar.test(pcStr[i + 3]) &&
                     isHexChar.test(pcStr[i + 4]) &&
                     isHexChar.test(pcStr[i + 5])) {
-                    var charCode = parseInt(pcStr.substring(i + 1, i + 6), 16);
+                    const charCode = parseInt(pcStr.substring(i + 1, i + 6), 16);
                     utf8Str += String.fromCharCode(charCode);
                     wasPercentEncoded = true;
                     i += 5; // Skip the next 5 chars
@@ -175,7 +183,7 @@ function strToUtf8(str) {
                 else if (i <= pcStrLen - 3 &&
                     isHexChar.test(pcStr[i + 1]) &&
                     isHexChar.test(pcStr[i + 2])) {
-                    var charCode = parseInt(pcStr.substring(i + 1, i + 3), 16);
+                    const charCode = parseInt(pcStr.substring(i + 1, i + 3), 16);
                     utf8Str += String.fromCharCode(charCode);
                     wasPercentEncoded = true;
                     i += 2; // Skip the next 2 chars
@@ -188,22 +196,23 @@ function strToUtf8(str) {
     }
     // Now let's just build our array from every other bytes of that string's
     // UTF-16 representation
-    var res = new Uint8Array(utf8Str.length);
-    for (var i = 0; i < utf8Str.length; i++) {
+    const res = new Uint8Array(utf8Str.length);
+    for (let i = 0; i < utf8Str.length; i++) {
         res[i] = utf8Str.charCodeAt(i) & 0xFF; // first byte should be 0x00 anyway
     }
     return res;
 }
+exports.strToUtf8 = strToUtf8;
 /**
  * Creates a new string from the given array of char codes.
  * @param {Uint8Array} args
  * @returns {string}
  */
 function stringFromCharCodes(args) {
-    var max = 16000;
-    var ret = "";
-    for (var i = 0; i < args.length; i += max) {
-        var subArray = args.subarray(i, i + max);
+    const max = 16000;
+    let ret = "";
+    for (let i = 0; i < args.length; i += max) {
+        const subArray = args.subarray(i, i + max);
         // NOTE: ugly I know, but TS is problematic here (you can try)
         ret += String.fromCharCode.apply(null, subArray);
     }
@@ -226,7 +235,7 @@ function stringFromCharCodes(args) {
  * @returns {string}
  */
 function intToHex(num, size) {
-    var toStr = num.toString(16);
+    const toStr = num.toString(16);
     return toStr.length >= size ? toStr :
         new Array(size - toStr.length + 1).join("0") + toStr;
 }
@@ -239,16 +248,16 @@ function utf8ToStr(data) {
     if (hasTextDecoder) {
         try {
             // TextDecoder use UTF-8 by default
-            var decoder = new TextDecoder();
+            const decoder = new TextDecoder();
             return decoder.decode(data);
         }
         catch (e) {
-            var err = e instanceof Error ? e : "";
-            log.warn("Utils: could not use TextDecoder to parse UTF-8, " +
+            const err = e instanceof Error ? e : "";
+            log_1.default.warn("Utils: could not use TextDecoder to parse UTF-8, " +
                 "fallbacking to another implementation", err);
         }
     }
-    var uint8 = data;
+    let uint8 = data;
     // If present, strip off the UTF-8 BOM.
     if (uint8[0] === 0xEF && uint8[1] === 0xBB && uint8[2] === 0xBF) {
         uint8 = uint8.subarray(3);
@@ -256,8 +265,8 @@ function utf8ToStr(data) {
     // We're basically doing strToUtf8 in reverse.
     // You can look at that other function for the whole story.
     // Generate string containing escaped UTF-8 code units
-    var utf8Str = stringFromCharCodes(uint8);
-    var escaped;
+    const utf8Str = stringFromCharCodes(uint8);
+    let escaped;
     if (typeof escape === "function") {
         // Transform UTF-8 escape sequence into percent-encoded escape sequences.
         escaped = escape(utf8Str);
@@ -265,14 +274,14 @@ function utf8ToStr(data) {
     else {
         // Let's implement a simple escape function
         // http://ecma-international.org/ecma-262/9.0/#sec-escape-string
-        var nonEscapedChar = /[A-Za-z0-9*_\+-\.\/]/;
+        const nonEscapedChar = /[A-Za-z0-9*_\+-\.\/]/;
         escaped = "";
-        for (var i = 0; i < utf8Str.length; i++) {
+        for (let i = 0; i < utf8Str.length; i++) {
             if (nonEscapedChar.test(utf8Str[i])) {
                 escaped += utf8Str[i];
             }
             else {
-                var charCode = utf8Str.charCodeAt(i);
+                const charCode = utf8Str.charCodeAt(i);
                 escaped += charCode >= 256 ? "%u" + intToHex(charCode, 4) :
                     "%" + intToHex(charCode, 2);
             }
@@ -282,6 +291,7 @@ function utf8ToStr(data) {
     // Example: "g#%E3%82%AC" -> "g#€"
     return decodeURIComponent(escaped);
 }
+exports.utf8ToStr = utf8ToStr;
 /**
  * Convert hex codes in a string form into the corresponding bytes.
  * @param {string} str
@@ -289,13 +299,14 @@ function utf8ToStr(data) {
  * @throws TypeError - str.length is odd
  */
 function hexToBytes(str) {
-    var len = str.length;
-    var arr = new Uint8Array(len / 2);
-    for (var i = 0, j = 0; i < len; i += 2, j++) {
+    const len = str.length;
+    const arr = new Uint8Array(len / 2);
+    for (let i = 0, j = 0; i < len; i += 2, j++) {
         arr[j] = parseInt(str.substring(i, i + 2), 16) & 0xFF;
     }
     return arr;
 }
+exports.hexToBytes = hexToBytes;
 /**
  * Convert bytes into the corresponding hex string, with the possibility
  * to add a separator.
@@ -303,10 +314,9 @@ function hexToBytes(str) {
  * @param {string} [sep=""] - separator. Separate each two hex character.
  * @returns {string}
  */
-function bytesToHex(bytes, sep) {
-    if (sep === void 0) { sep = ""; }
-    var hex = "";
-    for (var i = 0; i < bytes.byteLength; i++) {
+function bytesToHex(bytes, sep = "") {
+    let hex = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
         hex += (bytes[i] >>> 4).toString(16);
         hex += (bytes[i] & 0xF).toString(16);
         if (sep.length > 0 && i < bytes.byteLength - 1) {
@@ -315,6 +325,7 @@ function bytesToHex(bytes, sep) {
     }
     return hex;
 }
+exports.bytesToHex = bytesToHex;
 /**
  * Convert little-endian GUID into big-endian UUID.
  * @param {Uint8Array} guid
@@ -322,16 +333,16 @@ function bytesToHex(bytes, sep) {
  * @throws AssertionError - The guid length is not 16
  */
 function guidToUuid(guid) {
-    assert(guid.length === 16, "GUID length should be 16");
-    var p1A = guid[0];
-    var p1B = guid[1];
-    var p1C = guid[2];
-    var p1D = guid[3];
-    var p2A = guid[4];
-    var p2B = guid[5];
-    var p3A = guid[6];
-    var p3B = guid[7];
-    var uuid = new Uint8Array(16);
+    (0, assert_1.default)(guid.length === 16, "GUID length should be 16");
+    const p1A = guid[0];
+    const p1B = guid[1];
+    const p1C = guid[2];
+    const p1D = guid[3];
+    const p2A = guid[4];
+    const p2B = guid[5];
+    const p3A = guid[6];
+    const p3B = guid[7];
+    const uuid = new Uint8Array(16);
     // swapping byte endian on 4 bytes
     // [1, 2, 3, 4] => [4, 3, 2, 1]
     uuid[0] = p1D;
@@ -349,6 +360,7 @@ function guidToUuid(guid) {
     uuid.set(guid.subarray(8, 16), 8);
     return uuid;
 }
+exports.guidToUuid = guidToUuid;
 /**
  * Decode string from bytes (UTF-8).
  * Keeps reading until it reaches a byte that equals to zero.
@@ -357,16 +369,16 @@ function guidToUuid(guid) {
  * @returns {Object}
  */
 function readNullTerminatedString(buffer, offset) {
-    var position = offset;
+    let position = offset;
     while (position < buffer.length) {
-        var value = buffer[position];
+        const value = buffer[position];
         if (value === 0) {
             break;
         }
         position += 1;
     }
-    var bytes = buffer.subarray(offset, position);
+    const bytes = buffer.subarray(offset, position);
     return { end: position + 1,
         string: utf8ToStr(bytes) };
 }
-export { bytesToHex, hexToBytes, strToUtf8, utf8ToStr, strToUtf16LE, utf16LEToStr, strToBeUtf16, beUtf16ToStr, guidToUuid, readNullTerminatedString, };
+exports.readNullTerminatedString = readNullTerminatedString;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,20 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import isNullOrUndefined from "./is_null_or_undefined";
-export default function takeFirstSet() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    var i = 0;
-    var len = args.length;
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_null_or_undefined_1 = require("./is_null_or_undefined");
+function takeFirstSet(...args) {
+    let i = 0;
+    const len = args.length;
     while (i < len) {
-        var arg = args[i];
-        if (!isNullOrUndefined(arg)) {
+        const arg = args[i];
+        if (!(0, is_null_or_undefined_1.default)(arg)) {
             return arg;
         }
         i++;
     }
     return undefined;
 }
+exports.default = takeFirstSet;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,24 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import log from "../log";
-import assert from "./assert";
-import noop from "./noop";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationError = exports.CancellationSignal = void 0;
+const log_1 = require("../log");
+const assert_1 = require("./assert");
+const noop_1 = require("./noop");
 /**
  * Class facilitating asynchronous task cancellation.
  *
@@ -128,14 +116,14 @@ import noop from "./noop";
  * ```
  * @class TaskCanceller
  */
-var TaskCanceller = /** @class */ (function () {
+class TaskCanceller {
     /**
      * Creates a new `TaskCanceller`, with its own `CancellationSignal` created
      * as its `signal` provide.
      * You can then pass this property to async task you wish to be cancellable.
      */
-    function TaskCanceller() {
-        var _a = createCancellationFunctions(), trigger = _a[0], register = _a[1];
+    constructor() {
+        const [trigger, register] = createCancellationFunctions();
         this._isUsed = false;
         this._trigger = trigger;
         this.signal = new CancellationSignal(register);
@@ -144,9 +132,9 @@ var TaskCanceller = /** @class */ (function () {
      * Returns `true` if this `TaskCanceller` has already been triggered.
      * `false` otherwise.
      */
-    TaskCanceller.prototype.isUsed = function () {
+    isUsed() {
         return this._isUsed;
-    };
+    }
     /**
      * Bind this `TaskCanceller` to a `CancellationSignal`, so the former
      * is automatically cancelled when the latter is triggered.
@@ -161,14 +149,13 @@ var TaskCanceller = /** @class */ (function () {
      * @param {Object} signal
      * @returns {Function}
      */
-    TaskCanceller.prototype.linkToSignal = function (signal) {
-        var _this = this;
-        var unregister = signal.register(function () {
-            _this.cancel();
+    linkToSignal(signal) {
+        const unregister = signal.register(() => {
+            this.cancel();
         });
         this.signal.register(unregister);
         return unregister;
-    };
+    }
     /**
      * "Trigger" the `TaskCanceller`, notify through its associated
      * `CancellationSignal` (its `signal` property) that a task should be aborted.
@@ -180,14 +167,14 @@ var TaskCanceller = /** @class */ (function () {
      * cancellation.
      * @param {Error} [srcError]
      */
-    TaskCanceller.prototype.cancel = function (srcError) {
+    cancel(srcError) {
         if (this._isUsed) {
             return;
         }
         this._isUsed = true;
-        var cancellationError = srcError !== null && srcError !== void 0 ? srcError : new CancellationError();
+        const cancellationError = srcError !== null && srcError !== void 0 ? srcError : new CancellationError();
         this._trigger(cancellationError);
-    };
+    }
     /**
      * Check that the `error` in argument is a `CancellationError`, most likely
      * meaning that the linked error is due to a task aborted via a
@@ -195,38 +182,36 @@ var TaskCanceller = /** @class */ (function () {
      * @param {*} error
      * @returns {boolean}
      */
-    TaskCanceller.isCancellationError = function (error) {
+    static isCancellationError(error) {
         return error instanceof CancellationError;
-    };
-    return TaskCanceller;
-}());
-export default TaskCanceller;
+    }
+}
+exports.default = TaskCanceller;
 /**
  * Signal allowing to be notified when the linked task needs to be aborted.
  * @class
  */
-var CancellationSignal = /** @class */ (function () {
+class CancellationSignal {
     /**
      * Creates a new CancellationSignal.
      * /!\ Note: Only a `TaskCanceller` is supposed to be able to create one.
      * @param {Function} registerToSource - Function called when the task is
      * cancelled.
      */
-    function CancellationSignal(registerToSource) {
-        var _this = this;
+    constructor(registerToSource) {
         this._isCancelled = false;
         this.cancellationError = null;
         this._listeners = [];
-        registerToSource(function (cancellationError) {
-            _this.cancellationError = cancellationError;
-            _this._isCancelled = true;
-            while (_this._listeners.length > 0) {
+        registerToSource((cancellationError) => {
+            this.cancellationError = cancellationError;
+            this._isCancelled = true;
+            while (this._listeners.length > 0) {
                 try {
-                    var listener = _this._listeners.pop();
+                    const listener = this._listeners.pop();
                     listener === null || listener === void 0 ? void 0 : listener(cancellationError);
                 }
                 catch (err) {
-                    log.error("Error while calling clean up listener", err instanceof Error ? err.toString() :
+                    log_1.default.error("Error while calling clean up listener", err instanceof Error ? err.toString() :
                         "Unknown error");
                 }
             }
@@ -237,9 +222,9 @@ var CancellationSignal = /** @class */ (function () {
      * that the linked task needs to be aborted.
      * @returns boolean
      */
-    CancellationSignal.prototype.isCancelled = function () {
+    isCancelled() {
         return this._isCancelled;
-    };
+    }
     /**
      * Registers a function that will be called when/if the current task is
      * cancelled.
@@ -261,16 +246,15 @@ var CancellationSignal = /** @class */ (function () {
      * You don't need to call that function when cancellation has already been
      * performed.
      */
-    CancellationSignal.prototype.register = function (fn) {
-        var _this = this;
+    register(fn) {
         if (this._isCancelled) {
-            assert(this.cancellationError !== null);
+            (0, assert_1.default)(this.cancellationError !== null);
             fn(this.cancellationError);
-            return noop;
+            return noop_1.default;
         }
         this._listeners.push(fn);
-        return function () { return _this.deregister(fn); };
-    };
+        return () => this.deregister(fn);
+    }
     /**
      * De-register a function registered through the `register` function.
      * Do nothing if that function wasn't registered.
@@ -279,41 +263,37 @@ var CancellationSignal = /** @class */ (function () {
      * practical.
      * @param {Function} fn
      */
-    CancellationSignal.prototype.deregister = function (fn) {
-        for (var i = this._listeners.length - 1; i >= 0; i--) {
+    deregister(fn) {
+        for (let i = this._listeners.length - 1; i >= 0; i--) {
             if (this._listeners[i] === fn) {
                 this._listeners.splice(i, 1);
             }
         }
-    };
-    return CancellationSignal;
-}());
-export { CancellationSignal };
+    }
+}
+exports.CancellationSignal = CancellationSignal;
 /**
  * Error created when a task is cancelled.
  * @class CancellationError
  * @extends Error
  */
-var CancellationError = /** @class */ (function (_super) {
-    __extends(CancellationError, _super);
-    function CancellationError() {
-        var _this = _super.call(this) || this;
+class CancellationError extends Error {
+    constructor() {
+        super();
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
-        Object.setPrototypeOf(_this, CancellationError.prototype);
-        _this.name = "CancellationError";
-        _this.message = "This task was cancelled.";
-        return _this;
+        Object.setPrototypeOf(this, CancellationError.prototype);
+        this.name = "CancellationError";
+        this.message = "This task was cancelled.";
     }
-    return CancellationError;
-}(Error));
-export { CancellationError };
+}
+exports.CancellationError = CancellationError;
 /**
  * Helper function allowing communication between a `TaskCanceller` and a
  * `CancellationSignal`.
  * @returns {Array.<Function>}
  */
 function createCancellationFunctions() {
-    var listener = noop;
+    let listener = noop_1.default;
     return [
         function trigger(error) {
             listener(error);