api-def 0.7.4 → 0.8.0

package/esm/Requester.js

@@ -1,14 +1,3 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -18,33 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import * as ApiUtils from "./ApiUtils";
 import { inferResponseType, isAcceptableStatus, isNetworkError } from "./ApiUtils";
 import RequestContext from "./RequestContext";
@@ -54,241 +16,195 @@ import retry from "./util/retry";
 import MockRequestBackend from "./backend/MockRequestBackend";
 import { convertToRequestError, isRequestError, RequestErrorCode } from "./RequestError";
 import { textDecode } from "./TextDecoding";
-var locks = {};
-var runningOperations = {};
-var MOCK_REQUEST_BACKEND = new MockRequestBackend();
-export var submit = function (host, config, mocking) { return __awaiter(void 0, void 0, void 0, function () {
-    var computedConfig, backend, context, key, lock, lockedContext, response, successEventResult, error_1;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                computedConfig = host.computeConfig(config);
-                backend = mocking ? MOCK_REQUEST_BACKEND : Api.getRequestBackend();
-                if (!backend) {
-                    throw new Error("[api-def] Please specify a backend you wish to use, this can be done either with 'setRequestBackend()'");
-                }
-                context = new RequestContext(backend, host, computedConfig, host.computePath(host.path, config), mocking);
-                key = context.key;
-                lock = (context.computedConfig || {}).lock;
-                if (lock) {
-                    lockedContext = locks[lock];
-                    if (lockedContext && lockedContext.id !== context.id) {
-                        lockedContext.cancel();
-                    }
-                    locks[lock] = context;
-                }
-                _a.label = 1;
-            case 1:
-                _a.trys.push([1, 4, 5, 6]);
-                return [4 /*yield*/, (runningOperations[key] = makeRequest(context))];
-            case 2:
-                response = _a.sent();
-                return [4 /*yield*/, context.triggerEvent(RequestEvent.Success)];
-            case 3:
-                successEventResult = _a.sent();
-                if (successEventResult &&
-                    successEventResult.type === EventResultType.Respond) {
-                    context.response = response = successEventResult.response;
-                }
-                delete runningOperations[key];
-                return [2 /*return*/, response];
-            case 4:
-                error_1 = _a.sent();
-                delete runningOperations[key];
-                throw error_1;
-            case 5:
-                if (lock) {
-                    delete locks[lock];
-                }
-                return [7 /*endfinally*/];
-            case 6: return [2 /*return*/];
+const locks = {};
+const runningOperations = {};
+const MOCK_REQUEST_BACKEND = new MockRequestBackend();
+export const submit = (host, config, mocking) => __awaiter(void 0, void 0, void 0, function* () {
+    const computedConfig = host.computeConfig(config);
+    const backend = mocking ? MOCK_REQUEST_BACKEND : Api.getRequestBackend();
+    if (!backend) {
+        throw new Error("[api-def] Please specify a backend you wish to use, this can be done either with 'setRequestBackend()'");
+    }
+    const context = new RequestContext(backend, host, computedConfig, host.computePath(host.path, config), mocking);
+    const { key } = context;
+    // don't do this -- should only be for GET requests anyway and should be opt-in
+    /*
+    // if we are already running this request just return the same promise, no need to do it again
+    const sameRequest = runningOperations[key];
+    if (sameRequest) {
+      return sameRequest;
+    }
+    */
+    const { lock } = context.computedConfig || {};
+    if (typeof lock === "string") {
+        const lockedContext = locks[lock];
+        if (lockedContext && lockedContext.id !== context.id) {
+            lockedContext.cancel();
         }
-    });
-}); };
-var defaultBackendMessageShown = false;
-var makeRequest = function (context) { return __awaiter(void 0, void 0, void 0, function () {
-    var beforeSendEventResult, maxRetries, retryOpts, performRequest, response;
+        locks[lock] = context;
+    }
+    try {
+        let response = yield (runningOperations[key] = makeRequest(context));
+        const successEventResult = yield context.triggerEvent(RequestEvent.Success);
+        if (successEventResult &&
+            successEventResult.type === EventResultType.Respond) {
+            context.response = response = successEventResult.response;
+        }
+        delete runningOperations[key];
+        return response;
+    }
+    catch (error) {
+        delete runningOperations[key];
+        throw error;
+    }
+    finally {
+        if (typeof lock === "string") {
+            delete locks[lock];
+        }
+    }
+});
+let defaultBackendMessageShown = false;
+const makeRequest = (context) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (process.env.NODE_ENV === "development") {
-                    if (Api.isRequestBackendDefault() && !defaultBackendMessageShown) {
-                        defaultBackendMessageShown = true;
-                        // eslint-disable-next-line
-                        console.warn("[api-def] Using default fetch backend, you can use a different one with 'setRequestBackend()' (dev only message)");
-                    }
-                }
-                return [4 /*yield*/, context.triggerEvent(RequestEvent.BeforeSend)];
-            case 1:
-                beforeSendEventResult = _b.sent();
-                if (beforeSendEventResult &&
-                    beforeSendEventResult.type === EventResultType.Respond) {
-                    return [2 /*return*/, (context.response = beforeSendEventResult.response)];
+    if (process.env.NODE_ENV === "development") {
+        if (Api.isRequestBackendDefault() && !defaultBackendMessageShown) {
+            defaultBackendMessageShown = true;
+            // eslint-disable-next-line
+            console.warn("[api-def] Using default fetch backend, you can use a different one with 'setRequestBackend()' (dev only message)");
+        }
+    }
+    const beforeSendEventResult = yield context.triggerEvent(RequestEvent.BeforeSend);
+    if (beforeSendEventResult &&
+        beforeSendEventResult.type === EventResultType.Respond) {
+        return (context.response = beforeSendEventResult.response);
+    }
+    const maxRetries = ((_a = context.computedConfig) === null || _a === void 0 ? void 0 : _a.retry) || 0;
+    const retryOpts = {
+        retries: maxRetries,
+        // assume most users won't want to tune the delay between retries
+        minTimeout: 1 * 1000,
+        maxTimeout: 5 * 1000,
+        randomize: true,
+    };
+    context.stats.attempt = 0;
+    const performRequest = (fnBail, attemptCount) => __awaiter(void 0, void 0, void 0, function* () {
+        context.stats.attempt++;
+        try {
+            const { promise, canceler } = context.backend.makeRequest(context);
+            context.addCanceller(canceler);
+            const response = yield promise;
+            const parsedResponse = (yield parseResponse(context, response));
+            if (!isAcceptableStatus(parsedResponse.status, context.computedConfig.acceptableStatus)) {
+                throw convertToRequestError({
+                    error: new Error(`[api-def] Invalid response status code '${parsedResponse.status}'`),
+                    response: parsedResponse,
+                    code: RequestErrorCode.REQUEST_INVALID_STATUS,
+                    context: context,
+                });
+            }
+            context.response = parsedResponse;
+            return (parsedResponse);
+        }
+        catch (rawError) {
+            if (context.cancelled) {
+                rawError.isCancelledRequest = true;
+            }
+            const error = yield parseError(context, rawError);
+            context.error = error;
+            context.response = error.response;
+            const errorEventResult = yield context.triggerEvent(RequestEvent.Error);
+            if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
+                return errorEventResult.response;
+            }
+            // allow retry logic to handle network errors
+            const shouldNaturallyRetry = ApiUtils.isNetworkError(error);
+            if (shouldNaturallyRetry) {
+                throw error;
+            }
+            // if we have an event that tells us to retry, we must do it
+            const forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry;
+            if (forceRetry) {
+                return performRequest(fnBail, attemptCount);
+            }
+            // error is unrecoverable, bail
+            const unrecoverableErrorEventResult = yield context.triggerEvent(RequestEvent.UnrecoverableError);
+            if (unrecoverableErrorEventResult) {
+                if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
+                    return unrecoverableErrorEventResult.response;
                 }
-                maxRetries = ((_a = context.computedConfig) === null || _a === void 0 ? void 0 : _a.retry) || 0;
-                retryOpts = {
-                    retries: maxRetries,
-                    // assume most users won't want to tune the delay between retries
-                    minTimeout: 1 * 1000,
-                    maxTimeout: 5 * 1000,
-                    randomize: true,
-                };
-                context.stats.attempt = 0;
-                performRequest = function (fnBail, attemptCount) { return __awaiter(void 0, void 0, void 0, function () {
-                    var _a, promise, canceler, response_1, parsedResponse, rawError_1, error, errorEventResult, shouldNaturallyRetry, forceRetry, unrecoverableErrorEventResult;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                context.stats.attempt++;
-                                _b.label = 1;
-                            case 1:
-                                _b.trys.push([1, 4, , 8]);
-                                _a = context.backend.makeRequest(context), promise = _a.promise, canceler = _a.canceler;
-                                context.addCanceller(canceler);
-                                return [4 /*yield*/, promise];
-                            case 2:
-                                response_1 = _b.sent();
-                                return [4 /*yield*/, parseResponse(context, response_1)];
-                            case 3:
-                                parsedResponse = (_b.sent());
-                                if (!isAcceptableStatus(parsedResponse.status, context.computedConfig.acceptableStatus)) {
-                                    throw convertToRequestError({
-                                        error: new Error("[api-def] Invalid response status code '".concat(parsedResponse.status, "'")),
-                                        response: parsedResponse,
-                                        code: RequestErrorCode.REQUEST_INVALID_STATUS,
-                                        context: context,
-                                    });
-                                }
-                                context.response = parsedResponse;
-                                return [2 /*return*/, (parsedResponse)];
-                            case 4:
-                                rawError_1 = _b.sent();
-                                if (context.cancelled) {
-                                    rawError_1.isCancelledRequest = true;
-                                }
-                                return [4 /*yield*/, parseError(context, rawError_1)];
-                            case 5:
-                                error = _b.sent();
-                                context.error = error;
-                                context.response = error.response;
-                                return [4 /*yield*/, context.triggerEvent(RequestEvent.Error)];
-                            case 6:
-                                errorEventResult = _b.sent();
-                                if ((errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Respond) {
-                                    return [2 /*return*/, errorEventResult.response];
-                                }
-                                shouldNaturallyRetry = ApiUtils.isNetworkError(error);
-                                if (shouldNaturallyRetry) {
-                                    throw error;
-                                }
-                                forceRetry = (errorEventResult === null || errorEventResult === void 0 ? void 0 : errorEventResult.type) === EventResultType.Retry;
-                                if (forceRetry) {
-                                    return [2 /*return*/, performRequest(fnBail, attemptCount)];
-                                }
-                                return [4 /*yield*/, context.triggerEvent(RequestEvent.UnrecoverableError)];
-                            case 7:
-                                unrecoverableErrorEventResult = _b.sent();
-                                if (unrecoverableErrorEventResult) {
-                                    if (unrecoverableErrorEventResult.type === EventResultType.Respond) {
-                                        return [2 /*return*/, unrecoverableErrorEventResult.response];
-                                    }
-                                }
-                                fnBail(error);
-                                return [3 /*break*/, 8];
-                            case 8: return [2 /*return*/];
-                        }
-                    });
-                }); };
-                return [4 /*yield*/, retry(performRequest, retryOpts)];
-            case 2:
-                response = _b.sent();
-                return [2 /*return*/, (response)];
+            }
+            fnBail(error);
         }
     });
-}); };
-var parseResponse = function (context, response, error) { return __awaiter(void 0, void 0, void 0, function () {
-    var parsedResponse_1, contentType, inferredResponseType, data, decodedData;
-    var _a;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                if (!response) return [3 /*break*/, 2];
-                return [4 /*yield*/, context.backend.convertResponse(context, response)];
-            case 1:
-                parsedResponse_1 = _b.sent();
-                // lowercase all header names
-                parsedResponse_1.headers = parsedResponse_1.__lowercaseHeaders || Object.keys(parsedResponse_1.headers).reduce(function (headers, header) {
-                    headers[header.toLowerCase()] = parsedResponse_1.headers[header];
-                    return headers;
-                }, {});
-                contentType = parsedResponse_1.headers["content-type"];
-                inferredResponseType = inferResponseType(contentType);
-                if (!error) {
-                    // expand to array buffer once we support that in inferResponseType
-                    if (inferredResponseType === "text" && context.responseType === "json") {
-                        throw convertToRequestError({
-                            error: new Error("[api-def] Expected '".concat(context.responseType, "' response, got '").concat(inferredResponseType, "' (from 'Content-Type' of '").concat(contentType, "')")),
-                            code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                            response: parsedResponse_1,
-                            context: context,
-                        });
-                    }
-                    // transform arrayBuffer to json
-                    if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
-                        if (parsedResponse_1.data &&
-                            typeof parsedResponse_1.data === "object") {
-                            data = response.data;
-                            if (((_a = data.constructor) === null || _a === void 0 ? void 0 : _a.name) === "ArrayBuffer") {
-                                try {
-                                    decodedData = (response.data = textDecode(data));
-                                    response.data = JSON.parse(decodedData);
-                                }
-                                catch (e) {
-                                    throw convertToRequestError({
-                                        error: new Error("[api-def] Expected '".concat(context.responseType, "' response, got '").concat(inferredResponseType, "' (from 'Content-Type' of '").concat(contentType, "')")),
-                                        code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
-                                        response: parsedResponse_1,
-                                        context: context,
-                                    });
-                                }
-                            }
+    const response = yield retry(performRequest, retryOpts);
+    return (response);
+});
+const parseResponse = (context, response, error) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b;
+    if (response) {
+        const parsedResponse = yield context.backend.convertResponse(context, response);
+        // lowercase all header names
+        parsedResponse.headers = parsedResponse.__lowercaseHeaders || Object.keys(parsedResponse.headers).reduce((headers, header) => {
+            headers[header.toLowerCase()] = parsedResponse.headers[header];
+            return headers;
+        }, {});
+        const contentType = parsedResponse.headers["content-type"];
+        const inferredResponseType = inferResponseType(contentType);
+        if (!error) {
+            // expand to array buffer once we support that in inferResponseType
+            if (inferredResponseType === "text" && context.responseType === "json") {
+                throw convertToRequestError({
+                    error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                    code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                    response: parsedResponse,
+                    context: context,
+                });
+            }
+            // transform arrayBuffer to json
+            if (inferredResponseType === "arraybuffer" && context.responseType === "json") {
+                if (parsedResponse.data &&
+                    typeof parsedResponse.data === "object") {
+                    const data = response.data;
+                    if (((_b = data.constructor) === null || _b === void 0 ? void 0 : _b.name) === "ArrayBuffer") {
+                        try {
+                            const decodedData = (response.data = textDecode(data));
+                            response.data = JSON.parse(decodedData);
+                        }
+                        catch (e) {
+                            throw convertToRequestError({
+                                error: new Error(`[api-def] Expected '${context.responseType}' response, got '${inferredResponseType}' (from 'Content-Type' of '${contentType}')`),
+                                code: RequestErrorCode.REQUEST_MISMATCH_RESPONSE_TYPE,
+                                response: parsedResponse,
+                                context: context,
+                            });
                         }
                     }
                 }
-                return [2 /*return*/, parsedResponse_1];
-            case 2: return [2 /*return*/, response];
+            }
         }
-    });
-}); };
-var parseError = function (context, rawError) { return __awaiter(void 0, void 0, void 0, function () {
-    var error, extractedResponse, errorResponse, code, errorInfo;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                if (!isRequestError(rawError)) return [3 /*break*/, 1];
-                error = rawError;
-                return [3 /*break*/, 5];
-            case 1: return [4 /*yield*/, context.backend.extractResponseFromError(rawError)];
-            case 2:
-                extractedResponse = _a.sent();
-                errorResponse = undefined;
-                if (!(extractedResponse !== undefined)) return [3 /*break*/, 4];
-                return [4 /*yield*/, parseResponse(context, extractedResponse, true)];
-            case 3:
-                errorResponse = _a.sent();
-                _a.label = 4;
-            case 4:
-                code = isNetworkError(rawError) ? RequestErrorCode.REQUEST_NETWORK_ERROR : RequestErrorCode.MISC_UNKNOWN_ERROR;
-                if (errorResponse) {
-                    if (!isAcceptableStatus(errorResponse.status, context.computedConfig.acceptableStatus)) {
-                        code = RequestErrorCode.REQUEST_INVALID_STATUS;
-                    }
-                }
-                errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
-                error = convertToRequestError(__assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
-                _a.label = 5;
-            case 5: return [2 /*return*/, error];
+        return parsedResponse;
+    }
+    return response;
+});
+const parseError = (context, rawError) => __awaiter(void 0, void 0, void 0, function* () {
+    let error;
+    if (isRequestError(rawError)) {
+        error = rawError;
+    }
+    else {
+        const extractedResponse = yield context.backend.extractResponseFromError(rawError);
+        let errorResponse = undefined;
+        if (extractedResponse !== undefined) {
+            errorResponse = yield parseResponse(context, extractedResponse, true);
         }
-    });
-}); };
+        let code = isNetworkError(rawError) ? RequestErrorCode.REQUEST_NETWORK_ERROR : RequestErrorCode.MISC_UNKNOWN_ERROR;
+        if (errorResponse) {
+            if (!isAcceptableStatus(errorResponse.status, context.computedConfig.acceptableStatus)) {
+                code = RequestErrorCode.REQUEST_INVALID_STATUS;
+            }
+        }
+        const errorInfo = context.backend.getErrorInfo(rawError, errorResponse);
+        error = convertToRequestError(Object.assign({ error: rawError, response: errorResponse, code: code, context: context }, errorInfo));
+    }
+    return error;
+});

package/esm/TextDecoding.js

@@ -1,31 +1,31 @@
 /* eslint-disable prefer-const */
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 // polyfill from https://github.com/anonyco/FastestSmallestTextEncoderDecoder/blob/master/EncoderDecoderTogether.src.js
-export var textDecode = function (inputArrayOrBuffer, options) {
+export const textDecode = (inputArrayOrBuffer, options) => {
     if (typeof TextDecoder !== "undefined") {
         return new TextDecoder("utf-8").decode(inputArrayOrBuffer);
     }
-    var fromCharCode = String.fromCharCode;
-    var Object_prototype_toString = ({}).toString;
-    var sharedArrayBufferString = Object_prototype_toString.call(window["SharedArrayBuffer"]);
-    var undefinedObjectString = Object_prototype_toString();
-    var NativeUint8Array = window.Uint8Array;
-    var patchedU8Array = NativeUint8Array || Array;
-    var nativeArrayBuffer = NativeUint8Array ? ArrayBuffer : patchedU8Array;
-    var arrayBuffer_isView = nativeArrayBuffer.isView || function (x) {
+    const fromCharCode = String.fromCharCode;
+    const Object_prototype_toString = ({}).toString;
+    const sharedArrayBufferString = Object_prototype_toString.call(window["SharedArrayBuffer"]);
+    const undefinedObjectString = Object_prototype_toString();
+    const NativeUint8Array = window.Uint8Array;
+    const patchedU8Array = NativeUint8Array || Array;
+    const nativeArrayBuffer = NativeUint8Array ? ArrayBuffer : patchedU8Array;
+    const arrayBuffer_isView = nativeArrayBuffer.isView || function (x) {
         return x && "length" in x;
     };
-    var arrayBufferString = Object_prototype_toString.call(nativeArrayBuffer.prototype);
-    var tmpBufferU16 = new (NativeUint8Array ? Uint16Array : patchedU8Array)(32);
-    var inputAs8 = inputArrayOrBuffer;
-    var asObjectString;
+    const arrayBufferString = Object_prototype_toString.call(nativeArrayBuffer.prototype);
+    const tmpBufferU16 = new (NativeUint8Array ? Uint16Array : patchedU8Array)(32);
+    let inputAs8 = inputArrayOrBuffer;
+    let asObjectString;
     if (!arrayBuffer_isView(inputAs8)) {
         asObjectString = Object_prototype_toString.call(inputAs8);
         if (asObjectString !== arrayBufferString && asObjectString !== sharedArrayBufferString && asObjectString !== undefinedObjectString)
             throw TypeError("Failed to execute 'decode' on 'TextDecoder': The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
         inputAs8 = NativeUint8Array ? new patchedU8Array(inputAs8) : inputAs8 || [];
     }
-    var resultingString = "", tmpStr = "", index = 0, len = inputAs8.length | 0, lenMinus32 = len - 32 | 0, nextEnd = 0, cp0 = 0, codePoint = 0, minBits = 0, cp1 = 0, pos = 0, tmp = -1;
+    let resultingString = "", tmpStr = "", index = 0, len = inputAs8.length | 0, lenMinus32 = len - 32 | 0, nextEnd = 0, cp0 = 0, codePoint = 0, minBits = 0, cp1 = 0, pos = 0, tmp = -1;
     // Note that tmp represents the 2nd half of a surrogate pair incase a surrogate gets divided between blocks
     for (; index < len;) {
         nextEnd = index <= lenMinus32 ? 32 : len - index | 0;
@@ -34,29 +34,29 @@ export var textDecode = function (inputArrayOrBuffer, options) {
             switch (cp0 >> 4) {
                 case 15:
                     cp1 = inputAs8[index = index + 1 | 0] & 0xff;
-                    if ((cp1 >> 6) !== 2 || 247 < cp0) {
+                    if ((cp1 >> 6) !== 0b10 || 0b11110111 < cp0) {
                         index = index - 1 | 0;
                         break;
                     }
-                    codePoint = ((cp0 & 7) << 6) | (cp1 & 63);
+                    codePoint = ((cp0 & 0b111) << 6) | (cp1 & 0b00111111);
                     minBits = 5; // 20 ensures it never passes -> all invalid replacements
                     cp0 = 0x100; //  keep track of th bit size
                 // eslint-disable-next-line no-fallthrough
                 case 14:
                     cp1 = inputAs8[index = index + 1 | 0] & 0xff;
                     codePoint <<= 6;
-                    codePoint |= ((cp0 & 15) << 6) | (cp1 & 63);
-                    minBits = (cp1 >> 6) === 2 ? minBits + 4 | 0 : 24; // 24 ensures it never passes -> all invalid replacements
+                    codePoint |= ((cp0 & 0b1111) << 6) | (cp1 & 0b00111111);
+                    minBits = (cp1 >> 6) === 0b10 ? minBits + 4 | 0 : 24; // 24 ensures it never passes -> all invalid replacements
                     cp0 = (cp0 + 0x100) & 0x300; // keep track of th bit size
                 // eslint-disable-next-line no-fallthrough
                 case 13:
                 case 12:
                     cp1 = inputAs8[index = index + 1 | 0] & 0xff;
                     codePoint <<= 6;
-                    codePoint |= ((cp0 & 31) << 6) | cp1 & 63;
+                    codePoint |= ((cp0 & 0b11111) << 6) | cp1 & 0b00111111;
                     minBits = minBits + 7 | 0;
                     // Now, process the code point
-                    if (index < len && (cp1 >> 6) === 2 && (codePoint >> minBits) && codePoint < 0x110000) {
+                    if (index < len && (cp1 >> 6) === 0b10 && (codePoint >> minBits) && codePoint < 0x110000) {
                         cp0 = codePoint;
                         codePoint = codePoint - 0x10000 | 0;
                         if (0 <= codePoint /*0xffff < codePoint*/) { // BMP code point

package/esm/Utils.js

@@ -1,14 +1,14 @@
 // polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
-export var assign = Object.assign || function (target, varArgs) {
+export const assign = Object.assign || function (target, varArgs) {
     if (target === null || target === undefined) {
         throw new TypeError("Cannot convert undefined or null to object");
     }
-    var to = Object(target);
-    for (var index = 1; index < arguments.length; index++) {
+    const to = Object(target);
+    for (let index = 1; index < arguments.length; index++) {
         // eslint-disable-next-line prefer-rest-params
-        var nextSource = arguments[index];
+        const nextSource = arguments[index];
         if (nextSource !== null && nextSource !== undefined) {
-            for (var nextKey in nextSource) {
+            for (const nextKey in nextSource) {
                 // Avoid bugs when hasOwnProperty is shadowed
                 if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
                     to[nextKey] = nextSource[nextKey];
@@ -18,13 +18,13 @@ export var assign = Object.assign || function (target, varArgs) {
     }
     return to;
 };
-export var padNumber = function (stringOrNumber, maxLength) {
-    var string = stringOrNumber.toString();
+export const padNumber = (stringOrNumber, maxLength) => {
+    const string = stringOrNumber.toString();
     return string.length >= maxLength
         ? string
         : "0".repeat(maxLength - string.length) + string;
 };
-export var getGlobalFetch = function () {
+export const getGlobalFetch = () => {
     if (typeof global !== "undefined" && typeof global.fetch === "function") {
         return global.fetch;
     }
@@ -34,7 +34,7 @@ export var getGlobalFetch = function () {
     return window.fetch.bind(window);
 };
 // eslint-disable-next-line @typescript-eslint/no-empty-function
-export var noop = function () {
+export const noop = () => {
 };
 /**
  * Just used to simulate lag, or loading times.
@@ -42,10 +42,10 @@ export var noop = function () {
  * @param delayMs The delay in ms
  * @returns The `value` param as a Promise
  */
-export var delayThenReturn = function (value, delayMs) {
-    return (new Promise(function (resolve) {
+export const delayThenReturn = (value, delayMs) => {
+    return (new Promise((resolve) => {
         if (delayMs > 0) {
-            setTimeout(function () {
+            setTimeout(() => {
                 resolve(value);
             }, delayMs);
         }
@@ -54,8 +54,8 @@ export var delayThenReturn = function (value, delayMs) {
         }
     }));
 };
-export var randInt = function (min, max) {
-    var minI = Math.ceil(min);
-    var maxI = Math.floor(max);
+export const randInt = (min, max) => {
+    const minI = Math.ceil(min);
+    const maxI = Math.floor(max);
     return (Math.floor(Math.random() * (maxI - minI + 1)) + minI);
 };