@vertexvis/utils 1.0.2-testing.4 → 1.1.0

package/dist/bundle.js

@@ -1,4 +1,3 @@
-import { __awaiter, __generator, __asyncValues, __assign, __extends, __read, __spreadArray, __values } from 'tslib';
 import fastDeepEqual from 'fast-deep-equal';
 
 /**
@@ -10,17 +9,13 @@ import fastDeepEqual from '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 __awaiter(this, void 0, Promise, function () {
-        return __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);
     });
 }
 
@@ -36,109 +31,51 @@ var eventTargets = /*#__PURE__*/Object.freeze({
  * @returns A promise that resolves with an array of results yielded by the
  *  generator.
  */
-function asArray(generator) {
-    return __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 __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 = __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 __awaiter(this, void 0, Promise, function () {
-        var ms, promise, delay_1;
-        return __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 __awaiter(this, void 0, Promise, function () {
-        var ms, promise, timer_1, timeout_1, res;
-        return __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
@@ -155,43 +92,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 __awaiter(this, arguments, Promise, function (process, opts) {
-        function execute(attempt, process, opts) {
-            return __awaiter(this, void 0, Promise, function () {
-                var _a, delaysInMs, _b, maxRetries, delayInMs, e_2;
-                return __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 __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
@@ -205,27 +124,17 @@ function retry(process_1) {
  * @returns A value indicating if the process was aborted, or the value of
  * `promise`.
  */
-function abort(signal, promise) {
-    return __awaiter(this, void 0, Promise, function () {
-        var controller, pendingAbort, result;
-        return __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) {
@@ -247,7 +156,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) };
 };
 /**
@@ -255,27 +164,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 __assign(__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 __assign(__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 __assign(__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
@@ -283,9 +192,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 __assign(__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({
@@ -297,24 +206,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
 };
@@ -323,8 +231,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));
     }
@@ -334,12 +242,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));
     }
@@ -351,30 +259,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;
 };
 
@@ -463,28 +371,25 @@ var color = /*#__PURE__*/Object.freeze({
  *
  * @see {@link ifInvalidThrow} - for throwing errors on invalid input.
  */
-var MapperValidationError = /** @class */ (function (_super) {
-    __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.`] };
         }
     };
 }
@@ -496,13 +401,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`] };
         }
     };
 }
@@ -513,7 +418,7 @@ function requiredProp(prop) {
  * @param mapper A mapping function.
  */
 function ifDefined(mapper) {
-    return function (input) {
+    return (input) => {
         if (input != null) {
             return mapper(input);
         }
@@ -528,7 +433,7 @@ function ifDefined(mapper) {
  * @param prop The property to extract.
  */
 function getProp(prop) {
-    return function (input) {
+    return (input) => {
         return input[prop];
     };
 }
@@ -539,8 +444,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);
     };
 }
@@ -564,22 +469,22 @@ function mapRequiredProp(prop, mapper) {
  * @returns
  */
 function mapArray(mapper) {
-    return function (inputs) {
+    return (inputs) => {
         if (inputs.length > 0) {
-            var _a = __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: __spreadArray(__spreadArray([], __read(res.errors), false), __read(value.errors), false) }
+                        ? { errors: [...res.errors, ...value.errors] }
                         : value;
                 }
                 else if (isInvalid(res)) {
                     return res;
                 }
                 else {
-                    return __spreadArray(__spreadArray([], __read(res), false), [value], false);
+                    return [...res, value];
                 }
             }, isInvalid(first) ? first : [first]);
         }
@@ -603,8 +508,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);
         }
@@ -620,24 +525,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: __spreadArray(__spreadArray([], __read(res.errors), false), __read(value.errors), false) }
+                    ? { errors: [...res.errors, ...value.errors] }
                     : value;
             }
             else if (isInvalid(res)) {
                 return res;
             }
             else {
-                return __spreadArray(__spreadArray([], __read(res), false), [value], false);
+                return [...res, value];
             }
         }, []);
     };
@@ -706,18 +607,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;
             }
@@ -727,13 +624,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);
             }
@@ -763,19 +656,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 = __read(objects), a = _a[0], other = _a.slice(1);
-    var result = __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];
             }
@@ -786,7 +675,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);
     }
 }
 /**
@@ -812,7 +701,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;
 }
 /**
@@ -834,7 +723,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 [];
@@ -842,10 +731,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 __assign(__assign({}, result), (_a = {}, _a[pair[0]] = pair[1], _a));
+                return { ...result, [pair[0]]: pair[1] };
             }
             else {
                 return result;
@@ -870,25 +758,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);
 };
 /**
@@ -896,7 +784,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;
     }
@@ -913,7 +801,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;
     }
@@ -927,7 +815,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));
     }
@@ -935,54 +823,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);
 };
 /**
@@ -993,7 +881,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));
     }
@@ -1020,22 +908,11 @@ var range = /*#__PURE__*/Object.freeze({
 });
 
 function diffSet(a, b) {
-    var e_1, _a;
-    var res = new Set();
-    try {
-        for (var b_1 = __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;
 }
@@ -1045,9 +922,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, '');
 }
@@ -1068,7 +945,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;
     }
@@ -1083,12 +960,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 = __read(_a, 1), a = _c[0];
-        var _d = __read(_b, 1), b = _d[0];
-        return comparator(a, b);
-    };
+const head = (comparator) => {
+    return ([a], [b]) => comparator(a, b);
 };
 
 /**
@@ -1099,9 +972,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],
@@ -1120,54 +993,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 __assign(__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 = __spreadArray(__spreadArray([], __read(queryAsArray(uri)), false), [query], false);
-        return __assign(__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 __assign(__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.
@@ -1176,7 +1052,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);
     }
@@ -1184,12 +1060,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
@@ -1200,41 +1074,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 = __read(_a, 2), name = _c[0], value = _c[1];
-        return __assign(__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 */
@@ -1262,25 +1134,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 = __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() };
 }
 
@@ -1291,69 +1163,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 __awaiter(this, arguments, Promise, function (predicate, opts) {
-            var controller;
-            var _this = this;
-            var _a;
-            if (opts === void 0) { opts = {}; }
-            return __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);
-                            }
-                        }, __assign(__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));
+    }
+}
 
 export { async as Async, binaryReader as BinaryReader, color as Color, EventDispatcher, eventTargets as EventTargets, mapper as Mapper, objects as Objects, range as Range, sets as Sets, strings as Strings, uuid as UUID, uri as Uri };
 //# sourceMappingURL=bundle.js.map