@vertexvis/utils 1.0.2-testing.4 → 1.0.2-testing.5

package/dist/browser.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var tslib = require('tslib');
 var fastDeepEqual = require('fast-deep-equal');
 
 /**
@@ -12,17 +11,13 @@ var fastDeepEqual = require('fast-deep-equal');
  * @param opts Options to pass to `addEventListener`.
  * @returns A promise that resolves with the first event emitted of `type`.
  */
-function once(target, type, opts) {
-    return tslib.__awaiter(this, void 0, Promise, function () {
-        return tslib.__generator(this, function (_a) {
-            return [2 /*return*/, new Promise(function (resolve) {
-                    function handler(event) {
-                        target.removeEventListener(type, handler);
-                        resolve(event);
-                    }
-                    target.addEventListener(type, handler, opts);
-                })];
-        });
+async function once(target, type, opts) {
+    return new Promise((resolve) => {
+        function handler(event) {
+            target.removeEventListener(type, handler);
+            resolve(event);
+        }
+        target.addEventListener(type, handler, opts);
     });
 }
 
@@ -38,109 +33,51 @@ var eventTargets = /*#__PURE__*/Object.freeze({
  * @returns A promise that resolves with an array of results yielded by the
  *  generator.
  */
-function asArray(generator) {
-    return tslib.__awaiter(this, void 0, Promise, function () {
-        var res, next, e_1_1;
-        var _a, generator_1, generator_1_1;
-        var _b, e_1, _c, _d;
-        return tslib.__generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    res = [];
-                    _e.label = 1;
-                case 1:
-                    _e.trys.push([1, 6, 7, 12]);
-                    _a = true, generator_1 = tslib.__asyncValues(generator);
-                    _e.label = 2;
-                case 2: return [4 /*yield*/, generator_1.next()];
-                case 3:
-                    if (!(generator_1_1 = _e.sent(), _b = generator_1_1.done, !_b)) return [3 /*break*/, 5];
-                    _d = generator_1_1.value;
-                    _a = false;
-                    next = _d;
-                    res.push(next);
-                    _e.label = 4;
-                case 4:
-                    _a = true;
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 12];
-                case 6:
-                    e_1_1 = _e.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 12];
-                case 7:
-                    _e.trys.push([7, , 10, 11]);
-                    if (!(!_a && !_b && (_c = generator_1.return))) return [3 /*break*/, 9];
-                    return [4 /*yield*/, _c.call(generator_1)];
-                case 8:
-                    _e.sent();
-                    _e.label = 9;
-                case 9: return [3 /*break*/, 11];
-                case 10:
-                    if (e_1) throw e_1.error;
-                    return [7 /*endfinally*/];
-                case 11: return [7 /*endfinally*/];
-                case 12: return [2 /*return*/, res];
-            }
-        });
-    });
-}
-function delay() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
+async function asArray(generator) {
+    const res = [];
+    for await (const next of generator) {
+        res.push(next);
     }
-    return tslib.__awaiter(this, void 0, Promise, function () {
-        var ms, promise, delay_1;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ms = args[0];
-                    if (!(typeof ms === 'number')) return [3 /*break*/, 4];
-                    promise = args[1];
-                    delay_1 = new Promise(function (resolve) { return setTimeout(resolve, ms); });
-                    if (!(promise != null)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, delay_1];
-                case 1:
-                    _a.sent();
-                    return [2 /*return*/, promise];
-                case 2: return [2 /*return*/, delay_1];
-                case 3: return [3 /*break*/, 5];
-                case 4: return [2 /*return*/, Promise.reject(new TypeError('First argument to `delay` must be a number'))];
-                case 5: return [2 /*return*/];
-            }
-        });
-    });
+    return res;
 }
-function timeout() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
+async function delay(...args) {
+    const ms = args[0];
+    if (typeof ms === 'number') {
+        const promise = args[1];
+        const delay = new Promise((resolve) => setTimeout(resolve, ms));
+        if (promise != null) {
+            await delay;
+            return promise;
+        }
+        else {
+            return delay;
+        }
     }
-    return tslib.__awaiter(this, void 0, Promise, function () {
-        var ms, promise, timer_1, timeout_1, res;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ms = args[0];
-                    if (!(typeof ms === 'number')) return [3 /*break*/, 4];
-                    promise = args[1];
-                    timeout_1 = new Promise(function (_, reject) {
-                        timer_1 = setTimeout(function () { return reject(new Error("Promise timed out after ".concat(ms, "ms"))); }, ms);
-                    });
-                    if (!(promise != null)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, Promise.race([promise, timeout_1])];
-                case 1:
-                    res = _a.sent();
-                    clearTimeout(timer_1);
-                    return [2 /*return*/, res];
-                case 2: return [2 /*return*/, timeout_1];
-                case 3: return [3 /*break*/, 5];
-                case 4: return [2 /*return*/, Promise.reject('First argument to `timeout` must be a number')];
-                case 5: return [2 /*return*/];
-            }
+    else {
+        return Promise.reject(new TypeError('First argument to `delay` must be a number'));
+    }
+}
+async function timeout(...args) {
+    const ms = args[0];
+    if (typeof ms === 'number') {
+        const promise = args[1];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`Promise timed out after ${ms}ms`)), ms);
         });
-    });
+        if (promise != null) {
+            const res = await Promise.race([promise, timeout]);
+            clearTimeout(timer);
+            return res;
+        }
+        else {
+            return timeout;
+        }
+    }
+    else {
+        return Promise.reject('First argument to `timeout` must be a number');
+    }
 }
 /**
  * Executes and reattempts execution of an asynchronous function if it throws an
@@ -157,43 +94,25 @@ function timeout() {
  * @returns A promise that resolves with a successful value, or the original
  *  rejected value if the process fails.
  */
-function retry(process_1) {
-    return tslib.__awaiter(this, arguments, Promise, function (process, opts) {
-        function execute(attempt, process, opts) {
-            return tslib.__awaiter(this, void 0, Promise, function () {
-                var _a, delaysInMs, _b, maxRetries, delayInMs, e_2;
-                return tslib.__generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            _a = opts.delaysInMs, delaysInMs = _a === void 0 ? [] : _a, _b = opts.maxRetries, maxRetries = _b === void 0 ? 1 : _b;
-                            _c.label = 1;
-                        case 1:
-                            _c.trys.push([1, 4, , 8]);
-                            delayInMs = attempt === 0 || delaysInMs.length === 0
-                                ? 0
-                                : delaysInMs[Math.min(attempt - 1, delaysInMs.length - 1)];
-                            return [4 /*yield*/, delay(delayInMs)];
-                        case 2:
-                            _c.sent();
-                            return [4 /*yield*/, process()];
-                        case 3: return [2 /*return*/, _c.sent()];
-                        case 4:
-                            e_2 = _c.sent();
-                            if (!(attempt < maxRetries)) return [3 /*break*/, 6];
-                            return [4 /*yield*/, execute(attempt + 1, process, opts)];
-                        case 5: return [2 /*return*/, _c.sent()];
-                        case 6: throw e_2;
-                        case 7: return [3 /*break*/, 8];
-                        case 8: return [2 /*return*/];
-                    }
-                });
-            });
+async function retry(process, opts = {}) {
+    async function execute(attempt, process, opts) {
+        const { delaysInMs = [], maxRetries = 1 } = opts;
+        try {
+            const delayInMs = attempt === 0 || delaysInMs.length === 0
+                ? 0
+                : delaysInMs[Math.min(attempt - 1, delaysInMs.length - 1)];
+            await delay(delayInMs);
+            return await process();
         }
-        if (opts === void 0) { opts = {}; }
-        return tslib.__generator(this, function (_a) {
-            return [2 /*return*/, execute(0, process, opts)];
-        });
-    });
+        catch (e) {
+            if (attempt < maxRetries) {
+                return await execute(attempt + 1, process, opts);
+            }
+            else
+                throw e;
+        }
+    }
+    return execute(0, process, opts);
 }
 /**
  * Returns a promise that either resolves with the result of `promise`, or a
@@ -207,27 +126,17 @@ function retry(process_1) {
  * @returns A value indicating if the process was aborted, or the value of
  * `promise`.
  */
-function abort(signal, promise) {
-    return tslib.__awaiter(this, void 0, Promise, function () {
-        var controller, pendingAbort, result;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    controller = new AbortController();
-                    pendingAbort = once(signal, 'abort', { signal: controller.signal });
-                    return [4 /*yield*/, Promise.race([promise, pendingAbort])];
-                case 1:
-                    result = _a.sent();
-                    if (isAbortEvent(result)) {
-                        return [2 /*return*/, { aborted: true }];
-                    }
-                    else {
-                        controller.abort();
-                        return [2 /*return*/, { aborted: false, result: result }];
-                    }
-            }
-        });
-    });
+async function abort(signal, promise) {
+    const controller = new AbortController();
+    const pendingAbort = once(signal, 'abort', { signal: controller.signal });
+    const result = await Promise.race([promise, pendingAbort]);
+    if (isAbortEvent(result)) {
+        return { aborted: true };
+    }
+    else {
+        controller.abort();
+        return { aborted: false, result };
+    }
 }
 function isAbortEvent(obj) {
     if (obj instanceof Event) {
@@ -249,7 +158,7 @@ var async = /*#__PURE__*/Object.freeze({
 /**
  * Returns a new `BinaryReader` for an `ArrayBuffer`.
  */
-var fromArrayBuffer = function (buffer) {
+const fromArrayBuffer = (buffer) => {
     return { offset: 0, data: new DataView(buffer) };
 };
 /**
@@ -257,27 +166,27 @@ var fromArrayBuffer = function (buffer) {
  * reader's offset. The returned reader will have its offset adjusted so it can
  * be passed to the next helper.
  */
-var readInt32 = function (reader) {
-    var value = reader.data.getInt32(reader.offset);
-    return tslib.__assign(tslib.__assign({}, reader), { offset: reader.offset + 4, value: value });
+const readInt32 = (reader) => {
+    const value = reader.data.getInt32(reader.offset);
+    return { ...reader, offset: reader.offset + 4, value };
 };
 /**
  * Returns a `BinaryReader` that contains the read UTF-8 string at the given
  * reader's offset. The returned reader will have its offset adjusted so it can
  * be passed to the next helper.
  */
-var readUtf8String = function (length, reader) {
-    var value = String.fromCharCode.apply(null, Array.from(new Uint8Array(reader.data.buffer, reader.offset, length)));
-    return tslib.__assign(tslib.__assign({}, reader), { offset: reader.offset + length, value: value });
+const readUtf8String = (length, reader) => {
+    const value = String.fromCharCode.apply(null, Array.from(new Uint8Array(reader.data.buffer, reader.offset, length)));
+    return { ...reader, offset: reader.offset + length, value };
 };
 /**
  * Returns a `BinaryReader` that contains the a signed `Int8Array` start from
  * the given reader's offset to the given length. The returned reader will have
  * its offset adjusted so it can be passed to the next helper.
  */
-var readInt8Array = function (length, reader) {
-    var value = new Int8Array(reader.data.buffer, reader.offset, length);
-    return tslib.__assign(tslib.__assign({}, reader), { offset: reader.offset + length, value: value });
+const readInt8Array = (length, reader) => {
+    const value = new Int8Array(reader.data.buffer, reader.offset, length);
+    return { ...reader, offset: reader.offset + length, value };
 };
 /**
  * Returns a `BinaryReader` that contains the a signed `Int8Array` sliced from
@@ -285,9 +194,9 @@ var readInt8Array = function (length, reader) {
  * an offset of zero, so downstream operations will not bee effected by the
  * previous offset
  */
-var sliceInt8Array = function (length, reader) {
-    var value = new Int8Array(reader.data.buffer.slice(reader.offset, length + reader.offset));
-    return tslib.__assign(tslib.__assign({}, reader), { offset: 0, value: value });
+const sliceInt8Array = (length, reader) => {
+    const value = new Int8Array(reader.data.buffer.slice(reader.offset, length + reader.offset));
+    return { ...reader, offset: 0, value };
 };
 
 var binaryReader = /*#__PURE__*/Object.freeze({
@@ -299,24 +208,23 @@ var binaryReader = /*#__PURE__*/Object.freeze({
   sliceInt8Array: sliceInt8Array
 });
 
-var rgbRegex = /rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
-var rgbaRegex = /rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(.+)\s*\)/;
-var hexRegex = /^(#|0x)?([A-Fa-f0-9]{6})$/;
+const rgbRegex = /rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)/;
+const rgbaRegex = /rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(.+)\s*\)/;
+const hexRegex = /^(#|0x)?([A-Fa-f0-9]{6})$/;
 /**
  * Constructs a new color with the given red, green, blue and alpha values. If
  * alpha is undefined, defaults to 1.
  */
-var create$2 = function (r, g, b, a) {
-    if (a === void 0) { a = 255; }
-    return { r: r, g: g, b: b, a: a };
+const create$2 = (r, g, b, a = 255) => {
+    return { r, g, b, a };
 };
 /**
  * Converts a numeric color value containing red, green and blue values to a
  * `Color`. The alpha channel will default to fully opaque.
  */
-var fromNumber = function (num) {
+const fromNumber = (num) => {
     // tslint:disable:no-bitwise
-    var normalized = num & 0xffffff;
+    const normalized = num & 0xffffff;
     return create$2((normalized >> 16) & 0xff, (normalized >> 8) & 0xff, normalized & 0xff);
     // tslint:enable:no-bitwise
 };
@@ -325,8 +233,8 @@ var fromNumber = function (num) {
  * be parsed. Supports hex strings in the format of `"#00FF00"`, `"0x00FF00"` or
  * `"00FF00"`.
  */
-var fromHexString = function (str) {
-    var match = hexRegex.exec(str);
+const fromHexString = (str) => {
+    const match = hexRegex.exec(str);
     if (match != null) {
         return fromNumber(parseInt(match[2], 16));
     }
@@ -336,12 +244,12 @@ var fromHexString = function (str) {
  * supports `rgb(255, 255, 255)`, `rgba(255, 255, 255, 0.5)` or `"#FFFFFF"`.
  * Returns `undefined` if the color cannot be parsed.
  */
-var fromCss = function (css) {
-    var rgbMatch = rgbRegex.exec(css);
+const fromCss = (css) => {
+    const rgbMatch = rgbRegex.exec(css);
     if (rgbMatch != null) {
         return create$2(parseInt(rgbMatch[1]), parseInt(rgbMatch[2]), parseInt(rgbMatch[3]));
     }
-    var rgbaMatch = rgbaRegex.exec(css);
+    const rgbaMatch = rgbaRegex.exec(css);
     if (rgbaMatch != null) {
         return create$2(parseInt(rgbaMatch[1]), parseInt(rgbaMatch[2]), parseInt(rgbaMatch[3]), Math.floor(parseFloat(rgbaMatch[4]) * 255));
     }
@@ -353,30 +261,30 @@ var fromCss = function (css) {
  * Converts an array of four values to a `Color`. The sequence of the array is
  * expected to be `[r, g, b]` or `[r, g, b, a]`.
  */
-var fromArray = function (rgba) {
+const fromArray = (rgba) => {
     return create$2(rgba[0], rgba[1], rgba[2], rgba[3]);
 };
 /**
  * Returns `true` if the color's alpha channel is 0.
  */
-var isInvisible = function (color) {
+const isInvisible = (color) => {
     return color.a === 0;
 };
 /**
  * Returns `true` if the alpha channel of this color is fully opaque (255).
  */
-var isOpaque = function (color) {
+const isOpaque = (color) => {
     return color.a === 255;
 };
 /**
  * Converts a `Color` to a hex string. The returned string will be prefixed with
  * `#`.
  */
-var toHexString = function (color) {
-    return "#".concat(componentToHex(color.r)).concat(componentToHex(color.g)).concat(componentToHex(color.b));
+const toHexString = (color) => {
+    return `#${componentToHex(color.r)}${componentToHex(color.g)}${componentToHex(color.b)}`;
 };
-var componentToHex = function (num) {
-    var hex = num.toString(16);
+const componentToHex = (num) => {
+    const hex = num.toString(16);
     return hex.length === 1 ? '0' + hex : hex;
 };
 
@@ -465,28 +373,25 @@ var color = /*#__PURE__*/Object.freeze({
  *
  * @see {@link ifInvalidThrow} - for throwing errors on invalid input.
  */
-var MapperValidationError = /** @class */ (function (_super) {
-    tslib.__extends(MapperValidationError, _super);
-    function MapperValidationError(errors) {
-        var _this = _super.call(this, 'Validation error mapping object.') || this;
-        _this.errors = errors;
-        Object.setPrototypeOf(_this, MapperValidationError.prototype);
-        return _this;
+class MapperValidationError extends Error {
+    constructor(errors) {
+        super('Validation error mapping object.');
+        this.errors = errors;
+        Object.setPrototypeOf(this, MapperValidationError.prototype);
     }
-    return MapperValidationError;
-}(Error));
+}
 /**
  * Returns a mapper that asserts the input is not null or not undefined.
  *
  * @param name A name to report when invalid.
  */
 function required(name) {
-    return function (input) {
+    return (input) => {
         if (input != null) {
             return input;
         }
         else {
-            return { errors: ["".concat(name, " is required.")] };
+            return { errors: [`${name} is required.`] };
         }
     };
 }
@@ -498,13 +403,13 @@ function required(name) {
  * @returns A mapper that returns the property's value.
  */
 function requiredProp(prop) {
-    return function (obj) {
-        var value = obj[prop];
+    return (obj) => {
+        const value = obj[prop];
         if (value != null) {
             return value;
         }
         else {
-            return { errors: ["".concat(String(prop), " is required")] };
+            return { errors: [`${String(prop)} is required`] };
         }
     };
 }
@@ -515,7 +420,7 @@ function requiredProp(prop) {
  * @param mapper A mapping function.
  */
 function ifDefined(mapper) {
-    return function (input) {
+    return (input) => {
         if (input != null) {
             return mapper(input);
         }
@@ -530,7 +435,7 @@ function ifDefined(mapper) {
  * @param prop The property to extract.
  */
 function getProp(prop) {
-    return function (input) {
+    return (input) => {
         return input[prop];
     };
 }
@@ -541,8 +446,8 @@ function getProp(prop) {
  * @param mapper A function that will be invoked with the property's value.
  */
 function mapProp(prop, mapper) {
-    return function (input) {
-        var value = input[prop];
+    return (input) => {
+        const value = input[prop];
         return mapper(value);
     };
 }
@@ -566,22 +471,22 @@ function mapRequiredProp(prop, mapper) {
  * @returns
  */
 function mapArray(mapper) {
-    return function (inputs) {
+    return (inputs) => {
         if (inputs.length > 0) {
-            var _a = tslib.__read(inputs), head = _a[0], tail = _a.slice(1);
-            var first = mapper(head);
-            return tail.reduce(function (res, input) {
-                var value = mapper(input);
+            const [head, ...tail] = inputs;
+            const first = mapper(head);
+            return tail.reduce((res, input) => {
+                const value = mapper(input);
                 if (isInvalid(value)) {
                     return isInvalid(res)
-                        ? { errors: tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(res.errors), false), tslib.__read(value.errors), false) }
+                        ? { errors: [...res.errors, ...value.errors] }
                         : value;
                 }
                 else if (isInvalid(res)) {
                     return res;
                 }
                 else {
-                    return tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(res), false), [value], false);
+                    return [...res, value];
                 }
             }, isInvalid(first) ? first : [first]);
         }
@@ -605,8 +510,8 @@ function isInvalid(obj) {
  * @throws {@link MapperValidationError} If the input is invalid.
  */
 function ifInvalidThrow(mapper) {
-    return function (input) {
-        var value = mapper(input);
+    return (input) => {
+        const value = mapper(input);
         if (isInvalid(value)) {
             throw new MapperValidationError(value.errors);
         }
@@ -622,24 +527,20 @@ function ifValidThen(obj, f) {
         return f(obj);
     }
 }
-function read() {
-    var mappers = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        mappers[_i] = arguments[_i];
-    }
-    return function (input) {
-        return mappers.reduce(function (res, decoder) {
-            var value = decoder(input);
+function read(...mappers) {
+    return (input) => {
+        return mappers.reduce((res, decoder) => {
+            const value = decoder(input);
             if (isInvalid(value)) {
                 return isInvalid(res)
-                    ? { errors: tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(res.errors), false), tslib.__read(value.errors), false) }
+                    ? { errors: [...res.errors, ...value.errors] }
                     : value;
             }
             else if (isInvalid(res)) {
                 return res;
             }
             else {
-                return tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(res), false), [value], false);
+                return [...res, value];
             }
         }, []);
     };
@@ -708,18 +609,14 @@ function read() {
  * @see {@link read} - a helper function to read and validate input values.
  */
 function defineMapper(reader, builder) {
-    return function (input) {
-        var values = reader(input);
+    return (input) => {
+        const values = reader(input);
         return ifValidThen(values, builder);
     };
 }
-function compose() {
-    var decoders = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        decoders[_i] = arguments[_i];
-    }
-    return function (input) {
-        return decoders.reduce(function (last, decoder) {
+function compose(...decoders) {
+    return (input) => {
+        return decoders.reduce((last, decoder) => {
             if (isInvalid(last)) {
                 return last;
             }
@@ -729,13 +626,9 @@ function compose() {
         }, input);
     };
 }
-function pickFirst() {
-    var decoders = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        decoders[_i] = arguments[_i];
-    }
-    return function (input) {
-        return decoders.reduce(function (value, decoder) {
+function pickFirst(...decoders) {
+    return (input) => {
+        return decoders.reduce((value, decoder) => {
             if (value === undefined) {
                 return decoder(input);
             }
@@ -765,19 +658,15 @@ var mapper = /*#__PURE__*/Object.freeze({
   requiredProp: requiredProp
 });
 
-function defaults() {
-    var objects = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        objects[_i] = arguments[_i];
-    }
-    var _a = tslib.__read(objects), a = _a[0], other = _a.slice(1);
-    var result = tslib.__assign({}, a);
+function defaults(...objects) {
+    const [a, ...other] = objects;
+    const result = { ...a };
     if (other.length === 0) {
         return result;
     }
     else if (other.length === 1) {
-        var b = other[0];
-        for (var key in b) {
+        const b = other[0];
+        for (const key in b) {
             if (result[key] == null) {
                 result[key] = b[key];
             }
@@ -788,7 +677,7 @@ function defaults() {
         return result;
     }
     else {
-        return other.reduce(function (result, next) { return defaults(result, next); }, a);
+        return other.reduce((result, next) => defaults(result, next), a);
     }
 }
 /**
@@ -814,7 +703,7 @@ function isPlainObject(obj) {
     if (obj == null || typeof obj !== 'object') {
         return false;
     }
-    var prototype = Object.getPrototypeOf(obj);
+    const prototype = Object.getPrototypeOf(obj);
     return prototype != null && prototype.constructor === Object;
 }
 /**
@@ -836,7 +725,7 @@ function isEqual$1(a, b) {
 }
 function toPairs(obj) {
     if (obj != null) {
-        return Object.keys(obj).map(function (key) { return [key, obj[key]]; });
+        return Object.keys(obj).map((key) => [key, obj[key]]);
     }
     else {
         return [];
@@ -844,10 +733,9 @@ function toPairs(obj) {
 }
 function fromPairs(pairs) {
     if (Array.isArray(pairs)) {
-        return pairs.reduce(function (result, pair) {
-            var _a;
+        return pairs.reduce((result, pair) => {
             if (pair != null) {
-                return tslib.__assign(tslib.__assign({}, result), (_a = {}, _a[pair[0]] = pair[1], _a));
+                return { ...result, [pair[0]]: pair[1] };
             }
             else {
                 return result;
@@ -872,25 +760,25 @@ var objects = /*#__PURE__*/Object.freeze({
 /**
  * Returns a new `Range` with the given start and end points.
  */
-var create$1 = function (start, end) { return ({ start: start, end: end }); };
+const create$1 = (start, end) => ({ start, end });
 /**
  * Returns a new `Range` with the start and end points at the given position.
  */
-var at = function (position) { return ({
+const at = (position) => ({
     start: position,
     end: position,
-}); };
+});
 /**
  * Returns a new `Range` with the given start point and length.
  */
-var withLength = function (start, len) { return ({
-    start: start,
+const withLength = (start, len) => ({
+    start,
     end: start + len - 1,
-}); };
+});
 /**
  * Returns a range with the start and end points shifted by the given distance.
  */
-var add = function (distance, range) {
+const add = (distance, range) => {
     return create$1(range.start + distance, range.end + distance);
 };
 /**
@@ -898,7 +786,7 @@ var add = function (distance, range) {
  * of `to`. The function will try to maintain the length of the range, but will
  * shrink the range if its length is greater than `to`.
  */
-var constrain = function (range, to) {
+const constrain = (range, to) => {
     if (contains(range, to)) {
         return range;
     }
@@ -915,7 +803,7 @@ var constrain = function (range, to) {
 /**
  * Checks if the given number or range is contained within another range.
  */
-var contains = function (numOrRange, range) {
+const contains = (numOrRange, range) => {
     if (typeof numOrRange === 'number') {
         return range.start <= numOrRange && numOrRange <= range.end;
     }
@@ -929,7 +817,7 @@ var contains = function (numOrRange, range) {
  * @param other
  * @param range
  */
-var intersection = function (other, range) {
+const intersection = (other, range) => {
     if (intersects(other, range)) {
         return create$1(Math.max(other.start, range.start), Math.min(other.end, range.end));
     }
@@ -937,54 +825,54 @@ var intersection = function (other, range) {
 /**
  * Returns `true` if `other` intersects with `range`.
  */
-var intersects = function (other, range) {
+const intersects = (other, range) => {
     return ((other.start <= range.end && other.end >= range.start) ||
         (range.start <= other.end && range.end >= other.start));
 };
 /**
  * Checks if a range has the same starting point as another range.
  */
-var isAt = function (other, range) {
+const isAt = (other, range) => {
     return other.start === range.start;
 };
 /**
  * Returns `true` if a range's start point is after the starting point of
  * another range.
  */
-var isAfter = function (other, range) {
+const isAfter = (other, range) => {
     return other.start > range.start;
 };
 /**
  * Returns `true` if a range start at or is after another range.
  */
-var isAtOrAfter = function (other, range) {
+const isAtOrAfter = (other, range) => {
     return isAt(other, range) || isAfter(other, range);
 };
 /**
  * Returns `true` if a range's starting point is before another range's starting
  * point.
  */
-var isBefore = function (other, range) {
+const isBefore = (other, range) => {
     return other.start < range.start;
 };
 /**
  * Returns `true` if a range's starting point is at or before another range's
  * starting point.
  */
-var isAtOrBefore = function (other, range) {
+const isAtOrBefore = (other, range) => {
     return isAt(other, range) || isBefore(other, range);
 };
 /**
  * Returns the length of a range.
  */
-var length = function (range) {
+const length = (range) => {
     return range.end - range.start + 1;
 };
 /**
  * Returns a `Range` with its start and end points subtracted by the given
  * distance.
  */
-var subtract = function (distance, range) {
+const subtract = (distance, range) => {
     return add(distance * -1, range);
 };
 /**
@@ -995,7 +883,7 @@ var subtract = function (distance, range) {
  * If `other` does not intersect with `to`, then the range cannot be truncated
  * and `undefined` is returned.
  */
-var truncate = function (other, to) {
+const truncate = (other, to) => {
     if (intersects(to, other)) {
         return create$1(Math.max(other.start, to.start), Math.min(other.end, to.end));
     }
@@ -1022,22 +910,11 @@ var range = /*#__PURE__*/Object.freeze({
 });
 
 function diffSet(a, b) {
-    var e_1, _a;
-    var res = new Set();
-    try {
-        for (var b_1 = tslib.__values(b), b_1_1 = b_1.next(); !b_1_1.done; b_1_1 = b_1.next()) {
-            var item = b_1_1.value;
-            if (!a.has(item)) {
-                res.add(item);
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (b_1_1 && !b_1_1.done && (_a = b_1.return)) _a.call(b_1);
+    const res = new Set();
+    for (const item of b) {
+        if (!a.has(item)) {
+            res.add(item);
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return res;
 }
@@ -1047,9 +924,9 @@ var sets = /*#__PURE__*/Object.freeze({
   diffSet: diffSet
 });
 
-var trimStartRegex = /^\W+/;
-var trimEndRegex = /\W+$/;
-var trimStartAndEndRegex = /^\W+|\W+$/g;
+const trimStartRegex = /^\W+/;
+const trimEndRegex = /\W+$/;
+const trimStartAndEndRegex = /^\W+|\W+$/g;
 function trimStart(str) {
     return str.replace(trimStartRegex, '');
 }
@@ -1070,7 +947,7 @@ var strings = /*#__PURE__*/Object.freeze({
 /**
  * A comparator that sorts a number or string in ascending order.
  */
-var asc = function (a, b) {
+const asc = (a, b) => {
     if (a < b) {
         return -1;
     }
@@ -1085,12 +962,8 @@ var asc = function (a, b) {
  * A comparator that plucks the first element of an array and passes that value
  * to the given comparator for sorting.
  */
-var head = function (comparator) {
-    return function (_a, _b) {
-        var _c = tslib.__read(_a, 1), a = _c[0];
-        var _d = tslib.__read(_b, 1), b = _d[0];
-        return comparator(a, b);
-    };
+const head = (comparator) => {
+    return ([a], [b]) => comparator(a, b);
 };
 
 /**
@@ -1101,9 +974,9 @@ var head = function (comparator) {
  *
  * @param uri The URI to parse.
  */
-var parse = function (uri) {
-    var regex = /^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
-    var match = regex.exec(uri);
+const parse = (uri) => {
+    const regex = /^(([^:/?#]+):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
+    const match = regex.exec(uri);
     if (match != null) {
         return {
             scheme: match[2],
@@ -1122,54 +995,57 @@ var parse = function (uri) {
  * @param base
  * @param params
  */
-var parseAndAddParams = function (baseStr, params) {
-    var base = parse(baseStr);
+const parseAndAddParams = (baseStr, params) => {
+    const base = parse(baseStr);
     return params ? addQueryParams(params, base) : base;
 };
-var isEqual = function (a, b) {
-    var queryA = JSON.stringify(sortByQueryName(queryAsArray(a)));
-    var queryB = JSON.stringify(sortByQueryName(queryAsArray(b)));
+const isEqual = (a, b) => {
+    const queryA = JSON.stringify(sortByQueryName(queryAsArray(a)));
+    const queryB = JSON.stringify(sortByQueryName(queryAsArray(b)));
     return (a.scheme === b.scheme &&
         a.authority === b.authority &&
         a.path === b.path &&
         a.fragment === b.fragment &&
         queryA === queryB);
 };
-var replacePath = function (path, uri) {
-    var pathWithForwardSlash = path[0] === '/' ? path : "/".concat(path);
-    return tslib.__assign(tslib.__assign({}, uri), { path: pathWithForwardSlash });
+const replacePath = (path, uri) => {
+    const pathWithForwardSlash = path[0] === '/' ? path : `/${path}`;
+    return { ...uri, path: pathWithForwardSlash };
 };
-var pathAsArray = function (uri) {
+const pathAsArray = (uri) => {
     return uri.path != null ? sanitizePath(uri.path.split('/')) : [];
 };
-var appendPath = function (path, uri) {
-    var beforeParts = pathAsArray(uri);
-    var afterParts = sanitizePath(path.split('/'));
+const appendPath = (path, uri) => {
+    const beforeParts = pathAsArray(uri);
+    const afterParts = sanitizePath(path.split('/'));
     return replacePath(beforeParts.concat(afterParts).join('/'), uri);
 };
-var addQueryString = function (query, uri) {
-    var queryArray = stringAsQueryArray(query);
+const addQueryString = (query, uri) => {
+    const queryArray = stringAsQueryArray(query);
     return addQueryEntries(queryArray, uri);
 };
-var addQueryEntry = function (query, uri) {
+const addQueryEntry = (query, uri) => {
     if (query[1] != null) {
-        var newQuery = tslib.__spreadArray(tslib.__spreadArray([], tslib.__read(queryAsArray(uri)), false), [query], false);
-        return tslib.__assign(tslib.__assign({}, uri), { query: newQuery
-                .map(function (entry) { return entry.map(encodeURIComponent).join('='); })
-                .join('&') });
+        const newQuery = [...queryAsArray(uri), query];
+        return {
+            ...uri,
+            query: newQuery
+                .map((entry) => entry.map(encodeURIComponent).join('='))
+                .join('&'),
+        };
     }
     else {
         return uri;
     }
 };
-var addQueryEntries = function (entries, uri) {
-    return entries.reduce(function (result, entry) { return addQueryEntry(entry, result); }, uri);
+const addQueryEntries = (entries, uri) => {
+    return entries.reduce((result, entry) => addQueryEntry(entry, result), uri);
 };
-var addQueryParams = function (params, uri) {
-    return mapAsEntries(params).reduce(function (result, entry) { return addQueryEntry(entry, result); }, uri);
+const addQueryParams = (params, uri) => {
+    return mapAsEntries(params).reduce((result, entry) => addQueryEntry(entry, result), uri);
 };
-var replaceFragment = function (fragment, uri) {
-    return tslib.__assign(tslib.__assign({}, uri), { fragment: fragment });
+const replaceFragment = (fragment, uri) => {
+    return { ...uri, fragment };
 };
 /**
  * Return an array of name/value pairs representing the query string of a URI.
@@ -1178,7 +1054,7 @@ var replaceFragment = function (fragment, uri) {
  *
  * @param uri A URI to return the query string for.
  */
-var queryAsArray = function (uri) {
+const queryAsArray = (uri) => {
     if (uri.query != null) {
         return stringAsQueryArray(uri.query);
     }
@@ -1186,12 +1062,10 @@ var queryAsArray = function (uri) {
         return [];
     }
 };
-var stringAsQueryArray = function (queryString) {
+const stringAsQueryArray = (queryString) => {
     return queryString
         .split('&')
-        .map(function (param) {
-        return param.split('=').map(function (value) { return decodeURIComponent(value); });
-    });
+        .map((param) => param.split('=').map((value) => decodeURIComponent(value)));
 };
 /**
  * Return a map containing a URI's query string names and their values. The
@@ -1202,41 +1076,39 @@ var stringAsQueryArray = function (queryString) {
  *
  * @param uri A URI to return the query string for.
  */
-var queryAsMap = function (uri) {
-    return queryAsArray(uri).reduce(function (map, _a) {
-        var _b;
-        var _c = tslib.__read(_a, 2), name = _c[0], value = _c[1];
-        return tslib.__assign(tslib.__assign({}, map), (_b = {}, _b[name] = value, _b));
+const queryAsMap = (uri) => {
+    return queryAsArray(uri).reduce((map, [name, value]) => {
+        return { ...map, [name]: value };
     }, {});
 };
-var toString = function (uri) {
-    var result = '';
+const toString = (uri) => {
+    let result = '';
     if (uri.scheme != null && uri.scheme.length > 0) {
-        result = "".concat(uri.scheme, ":");
+        result = `${uri.scheme}:`;
     }
     if (uri.authority != null && uri.authority.length > 0) {
-        result += "//".concat(uri.authority);
+        result += `//${uri.authority}`;
     }
     result += uri.path;
     if (uri.query != null && uri.query.length > 0) {
-        result += "?".concat(uri.query);
+        result += `?${uri.query}`;
     }
     if (uri.fragment != null && uri.fragment.length > 0) {
-        result += "#".concat(uri.fragment);
+        result += `#${uri.fragment}`;
     }
     return result;
 };
-var sanitizePath = function (path) {
-    return path.filter(function (segment) { return segment.length > 0; });
+const sanitizePath = (path) => {
+    return path.filter((segment) => segment.length > 0);
 };
-var mapAsEntries = function (map) {
-    var entries = [];
-    for (var key in map) {
+const mapAsEntries = (map) => {
+    const entries = [];
+    for (const key in map) {
         entries.push([key, map[key]]);
     }
     return entries;
 };
-var sortByQueryName = function (entries) {
+const sortByQueryName = (entries) => {
     return entries.concat().sort(head(asc));
 };
 /* eslint-enable @typescript-eslint/no-explicit-any */
@@ -1264,25 +1136,25 @@ function create() {
 }
 function fromMsbLsb(msb, lsb) {
     function digits(val, ds) {
-        var hi = BigInt(1) << (ds * BigInt(4));
+        const hi = BigInt(1) << (ds * BigInt(4));
         return (hi | (val & (hi - BigInt(1)))).toString(16).substring(1);
     }
-    var msbB = typeof msb === 'string' ? BigInt(msb) : msb;
-    var lsbB = typeof lsb === 'string' ? BigInt(lsb) : lsb;
-    var sec1 = digits(msbB >> BigInt(32), BigInt(8));
-    var sec2 = digits(msbB >> BigInt(16), BigInt(4));
-    var sec3 = digits(msbB, BigInt(4));
-    var sec4 = digits(lsbB >> BigInt(48), BigInt(4));
-    var sec5 = digits(lsbB, BigInt(12));
-    return "".concat(sec1, "-").concat(sec2, "-").concat(sec3, "-").concat(sec4, "-").concat(sec5);
+    const msbB = typeof msb === 'string' ? BigInt(msb) : msb;
+    const lsbB = typeof lsb === 'string' ? BigInt(lsb) : lsb;
+    const sec1 = digits(msbB >> BigInt(32), BigInt(8));
+    const sec2 = digits(msbB >> BigInt(16), BigInt(4));
+    const sec3 = digits(msbB, BigInt(4));
+    const sec4 = digits(lsbB >> BigInt(48), BigInt(4));
+    const sec5 = digits(lsbB, BigInt(12));
+    return `${sec1}-${sec2}-${sec3}-${sec4}-${sec5}`;
 }
 function toMsbLsb(id) {
-    var _a = tslib.__read(id.split('-'), 5), c1 = _a[0], c2 = _a[1], c3 = _a[2], c4 = _a[3], c5 = _a[4];
+    const [c1, c2, c3, c4, c5] = id.split('-');
     if (c1 == null || c2 == null || c3 == null || c4 == null || c5 == null) {
-        throw new Error("Invalid UUID string ".concat(id));
+        throw new Error(`Invalid UUID string ${id}`);
     }
-    var msb = BigInt.asIntN(64, BigInt("0x".concat(c1 + c2 + c3)));
-    var lsb = BigInt.asIntN(64, BigInt("0x".concat(c4 + c5)));
+    const msb = BigInt.asIntN(64, BigInt(`0x${c1 + c2 + c3}`));
+    const lsb = BigInt.asIntN(64, BigInt(`0x${c4 + c5}`));
     return { msb: msb.toString(), lsb: lsb.toString() };
 }
 
@@ -1293,69 +1165,56 @@ var uuid = /*#__PURE__*/Object.freeze({
   toMsbLsb: toMsbLsb
 });
 
-var EventDispatcher = /** @class */ (function () {
-    function EventDispatcher() {
+class EventDispatcher {
+    constructor() {
         this.listeners = [];
     }
-    EventDispatcher.prototype.on = function (listener, opts) {
-        var _this = this;
+    on(listener, opts = {}) {
         var _a;
-        if (opts === void 0) { opts = {}; }
         this.listeners.push(listener);
-        var controller = new AbortController();
-        controller.signal.addEventListener('abort', function () { return _this.off(listener); });
-        (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', function () { return controller.abort(); });
-        return { dispose: function () { return controller.abort(); } };
-    };
-    EventDispatcher.prototype.once = function (opts) {
-        var _this = this;
-        if (opts === void 0) { opts = {}; }
-        return new Promise(function (resolve) {
-            var subscription = _this.on(function (event) {
+        const controller = new AbortController();
+        controller.signal.addEventListener('abort', () => this.off(listener));
+        (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', () => controller.abort());
+        return { dispose: () => controller.abort() };
+    }
+    once(opts = {}) {
+        return new Promise((resolve) => {
+            const subscription = this.on((event) => {
                 subscription.dispose();
                 resolve(event);
             }, opts);
         });
-    };
-    EventDispatcher.prototype.onceWhen = function (predicate_1) {
-        return tslib.__awaiter(this, arguments, Promise, function (predicate, opts) {
-            var controller;
-            var _this = this;
-            var _a;
-            if (opts === void 0) { opts = {}; }
-            return tslib.__generator(this, function (_b) {
-                controller = new AbortController();
-                (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', function () { return controller.abort(); });
-                return [2 /*return*/, new Promise(function (resolve) {
-                        _this.when(predicate, function (event) {
-                            if (predicate(event)) {
-                                controller.abort();
-                                resolve(event);
-                            }
-                        }, tslib.__assign(tslib.__assign({}, opts), { abort: controller.signal }));
-                    })];
-            });
+    }
+    async onceWhen(predicate, opts = {}) {
+        var _a;
+        const controller = new AbortController();
+        (_a = opts.abort) === null || _a === void 0 ? void 0 : _a.addEventListener('abort', () => controller.abort());
+        return new Promise((resolve) => {
+            this.when(predicate, (event) => {
+                if (predicate(event)) {
+                    controller.abort();
+                    resolve(event);
+                }
+            }, { ...opts, abort: controller.signal });
         });
-    };
-    EventDispatcher.prototype.when = function (predicate, listener, opts) {
-        if (opts === void 0) { opts = {}; }
-        return this.on(function (event) {
+    }
+    when(predicate, listener, opts = {}) {
+        return this.on((event) => {
             if (predicate(event)) {
                 listener(event);
             }
         }, opts);
-    };
-    EventDispatcher.prototype.off = function (listener) {
-        var index = this.listeners.indexOf(listener);
+    }
+    off(listener) {
+        const index = this.listeners.indexOf(listener);
         if (index !== -1) {
             this.listeners.splice(index, 1);
         }
-    };
-    EventDispatcher.prototype.emit = function (event) {
-        this.listeners.forEach(function (listener) { return listener(event); });
-    };
-    return EventDispatcher;
-}());
+    }
+    emit(event) {
+        this.listeners.forEach((listener) => listener(event));
+    }
+}
 
 exports.Async = async;
 exports.BinaryReader = binaryReader;