@esri/telemetry-amazon 3.0.1 → 4.0.1

package/dist/umd/telemetry-amazon.min.js

@@ -4971,72 +4971,6 @@
         return t;
     }
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    var __assign$1 = function() {
-        __assign$1 = Object.assign || function __assign(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$1.apply(this, arguments);
-    };
-
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    var __assign = function() {
-        __assign = Object.assign || function __assign(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);
-    };
-
     /* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     /**
@@ -5045,15 +4979,15 @@
      * @return A boolean indicating if FormData will be required.
      */
     function requiresFormData(params) {
-        return Object.keys(params).some(function (key) {
-            var value = params[key];
+        return Object.keys(params).some((key) => {
+            let value = params[key];
             if (!value) {
                 return false;
             }
             if (value && value.toParam) {
                 value = value.toParam();
             }
-            var type = value.constructor.name;
+            const type = value.constructor.name;
             switch (type) {
                 case "Array":
                     return false;
@@ -5080,10 +5014,10 @@
      * @return A new object with properly encoded values.
      */
     function processParams(params) {
-        var newParams = {};
-        Object.keys(params).forEach(function (key) {
+        const newParams = {};
+        Object.keys(params).forEach((key) => {
             var _a, _b;
-            var param = params[key];
+            let param = params[key];
             if (param && param.toParam) {
                 param = param.toParam();
             }
@@ -5093,8 +5027,8 @@
                 typeof param !== "string") {
                 return;
             }
-            var type = param.constructor.name;
-            var value;
+            const type = param.constructor.name;
+            let value;
             // properly encodes objects, arrays and dates for arcgis.com and other services.
             // ported from https://github.com/Esri/esri-leaflet/blob/master/src/Request.js#L22-L30
             // also see https://github.com/Esri/arcgis-rest-js/issues/18:
@@ -5104,11 +5038,13 @@
                     // Based on the first element of the array, classify array as an array of arrays, an array of objects
                     // to be stringified, or an array of non-objects to be comma-separated
                     // eslint-disable-next-line no-case-declarations
-                    var firstElementType = (_b = (_a = param[0]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
+                    const firstElementType = (_b = (_a = param[0]) === null || _a === void 0 ? void 0 : _a.constructor) === null || _b === void 0 ? void 0 : _b.name;
                     value =
-                        firstElementType === "Array" ? param : // pass thru array of arrays
-                            firstElementType === "Object" ? JSON.stringify(param) : // stringify array of objects
-                                param.join(","); // join other types of array elements
+                        firstElementType === "Array"
+                            ? param // pass thru array of arrays
+                            : firstElementType === "Object"
+                                ? JSON.stringify(param) // stringify array of objects
+                                : param.join(","); // join other types of array elements
                     break;
                 case "Object":
                     value = JSON.stringify(param);
@@ -5126,7 +5062,10 @@
                     value = param;
                     break;
             }
-            if (value || value === 0 || typeof value === "string" || Array.isArray(value)) {
+            if (value ||
+                value === 0 ||
+                typeof value === "string" ||
+                Array.isArray(value)) {
                 newParams[key] = value;
             }
         });
@@ -5145,7 +5084,9 @@
     function encodeParam(key, value) {
         // For array of arrays, repeat key=value for each element of containing array
         if (Array.isArray(value) && value[0] && Array.isArray(value[0])) {
-            return value.map(function (arrayElem) { return encodeParam(key, arrayElem); }).join("&");
+            return value
+                .map((arrayElem) => encodeParam(key, arrayElem))
+                .join("&");
         }
         return encodeURIComponent(key) + "=" + encodeURIComponent(value);
     }
@@ -5156,14 +5097,16 @@
      * @returns An encoded query string.
      */
     function encodeQueryString(params) {
-        var newParams = processParams(params);
+        const newParams = processParams(params);
         return Object.keys(newParams)
-            .map(function (key) {
+            .map((key) => {
             return encodeParam(key, newParams[key]);
         })
             .join("&");
     }
 
+    const FormData = globalThis.FormData;
+
     /* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     /**
@@ -5174,25 +5117,25 @@
      */
     function encodeFormData(params, forceFormData) {
         // see https://github.com/Esri/arcgis-rest-js/issues/499 for more info.
-        var useFormData = requiresFormData(params) || forceFormData;
-        var newParams = processParams(params);
+        const useFormData = requiresFormData(params) || forceFormData;
+        const newParams = processParams(params);
         if (useFormData) {
-            var formData_1 = new FormData();
-            Object.keys(newParams).forEach(function (key) {
+            const formData = new FormData();
+            Object.keys(newParams).forEach((key) => {
                 if (typeof Blob !== "undefined" && newParams[key] instanceof Blob) {
                     /* To name the Blob:
                      1. look to an alternate request parameter called 'fileName'
                      2. see if 'name' has been tacked onto the Blob manually
                      3. if all else fails, use the request parameter
                     */
-                    var filename = newParams["fileName"] || newParams[key].name || key;
-                    formData_1.append(key, newParams[key], filename);
+                    const filename = newParams["fileName"] || newParams[key].name || key;
+                    formData.append(key, newParams[key], filename);
                 }
                 else {
-                    formData_1.append(key, newParams[key]);
+                    formData.append(key, newParams[key]);
                 }
             });
-            return formData_1;
+            return formData;
         }
         else {
             return encodeQueryString(params);
@@ -5201,11 +5144,20 @@
 
     /* Copyright (c) 2017 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
-    // TypeScript 2.1 no longer allows you to extend built in types. See https://github.com/Microsoft/TypeScript/issues/12790#issuecomment-265981442
-    // and https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-    //
-    // This code is from MDN https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types.
-    var ArcGISRequestError = /** @class */ (function () {
+    /**
+     * This represents a generic error from an ArcGIS endpoint. There will be details about the error in the {@linkcode ArcGISRequestError.message},  {@linkcode ArcGISRequestError.originalMessage} properties on the error. You
+     * can also access the original server response at  {@linkcode ArcGISRequestError.response} which may have additional details.
+     *
+     * ```js
+     * request(someUrl, someOptions).catch(e => {
+     *   if(e.name === "ArcGISRequestError") {
+     *     console.log("Something went wrong with the request:", e);
+     *     console.log("Full server response", e.response);
+     *   }
+     * })
+     * ```
+     */
+    class ArcGISRequestError extends Error {
         /**
          * Create a new `ArcGISRequestError`  object.
          *
@@ -5215,34 +5167,82 @@
          * @param url - The original url of the request
          * @param options - The original options and parameters of the request
          */
-        function ArcGISRequestError(message, code, response, url, options) {
+        constructor(message, code, response, url, options) {
+            // 'Error' breaks prototype chain here
+            super(message);
+            // restore prototype chain, see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+            // we don't need to check for Object.setPrototypeOf as in the answers because we are ES2017 now.
+            // Also see https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+            // and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#custom_error_types
+            const actualProto = new.target.prototype;
+            Object.setPrototypeOf(this, actualProto);
             message = message || "UNKNOWN_ERROR";
             code = code || "UNKNOWN_ERROR_CODE";
             this.name = "ArcGISRequestError";
             this.message =
-                code === "UNKNOWN_ERROR_CODE" ? message : code + ": " + message;
+                code === "UNKNOWN_ERROR_CODE" ? message : `${code}: ${message}`;
             this.originalMessage = message;
             this.code = code;
             this.response = response;
             this.url = url;
             this.options = options;
         }
-        return ArcGISRequestError;
-    }());
-    ArcGISRequestError.prototype = Object.create(Error.prototype);
-    ArcGISRequestError.prototype.constructor = ArcGISRequestError;
+    }
 
     /* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
-    var NODEJS_DEFAULT_REFERER_HEADER = "@esri/arcgis-rest-js";
-    var DEFAULT_ARCGIS_REQUEST_OPTIONS = {
-        httpMethod: "POST",
-        params: {
-            f: "json",
-        },
-    };
-    var ArcGISAuthError = /** @class */ (function (_super) {
-        __extends(ArcGISAuthError, _super);
+    /**
+     * Method used internally to surface messages to developers.
+     */
+    function warn(message) {
+        if (console && console.warn) {
+            console.warn.apply(console, [message]);
+        }
+    }
+
+    function getFetch() {
+      return Promise.resolve({
+        fetch: globalThis.fetch,
+        Headers: globalThis.Headers,
+        Response: globalThis.Response,
+        Request: globalThis.Request
+      });
+    }
+
+    /* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
+     * Apache-2.0 */
+    const NODEJS_DEFAULT_REFERER_HEADER = `@esri/arcgis-rest-js`;
+    function getDefaultRequestOptions() {
+        return (globalThis.DEFAULT_ARCGIS_REQUEST_OPTIONS || {
+            httpMethod: "POST",
+            params: {
+                f: "json"
+            }
+        });
+    }
+    /**
+     * This error is thrown when a request encounters an invalid token error. Requests that use {@linkcode ArcGISIdentityManager} or
+     * {@linkcode ApplicationCredentialsManager} in the `authentication` option the authentication manager will automatically try to generate
+     * a fresh token using either {@linkcode ArcGISIdentityManager.refreshCredentials} or
+     * {@linkcode ApplicationCredentialsManager.refreshCredentials}. If the request with the new token fails you will receive an `ArcGISAuthError`
+     * if refreshing the token fails you will receive an instance of {@linkcode ArcGISTokenRequestError}.
+     *
+     * ```js
+     * request(someUrl, {
+     *   authentication: identityManager,
+     *   // some additional options...
+     * }).catch(e => {
+     *   if(e.name === "ArcGISAuthError") {
+     *     console.log("Request with a new token failed you might want to have the user authorize again.")
+     *   }
+     *
+     *   if(e.name === "ArcGISTokenRequestError") {
+     *     console.log("There was an error refreshing the token you might want to have the user authorize again.")
+     *   }
+     * })
+     * ```
+     */
+    class ArcGISAuthError extends ArcGISRequestError {
         /**
          * Create a new `ArcGISAuthError`  object.
          *
@@ -5252,47 +5252,49 @@
          * @param url - The original url of the request
          * @param options - The original options of the request
          */
-        function ArcGISAuthError(message, code, response, url, options) {
-            if (message === void 0) { message = "AUTHENTICATION_ERROR"; }
-            if (code === void 0) { code = "AUTHENTICATION_ERROR_CODE"; }
-            var _this = _super.call(this, message, code, response, url, options) || this;
-            _this.name = "ArcGISAuthError";
-            _this.message =
-                code === "AUTHENTICATION_ERROR_CODE" ? message : code + ": " + message;
-            return _this;
+        constructor(message = "AUTHENTICATION_ERROR", code = "AUTHENTICATION_ERROR_CODE", response, url, options) {
+            super(message, code, response, url, options);
+            this.name = "ArcGISAuthError";
+            this.message =
+                code === "AUTHENTICATION_ERROR_CODE" ? message : `${code}: ${message}`;
+            // restore prototype chain, see https://stackoverflow.com/questions/41102060/typescript-extending-error-class
+            // we don't need to check for Object.setPrototypeOf as in the answers because we are ES2017 now.
+            // Also see https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+            // and https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#custom_error_types
+            const actualProto = new.target.prototype;
+            Object.setPrototypeOf(this, actualProto);
         }
-        ArcGISAuthError.prototype.retry = function (getSession, retryLimit) {
-            var _this = this;
-            if (retryLimit === void 0) { retryLimit = 3; }
-            var tries = 0;
-            var retryRequest = function (resolve, reject) {
-                getSession(_this.url, _this.options)
-                    .then(function (session) {
-                    var newOptions = __assign(__assign({}, _this.options), { authentication: session });
-                    tries = tries + 1;
-                    return request(_this.url, newOptions);
+        retry(getSession, retryLimit = 1) {
+            let tries = 0;
+            const retryRequest = (resolve, reject) => {
+                tries = tries + 1;
+                getSession(this.url, this.options)
+                    .then((session) => {
+                    const newOptions = Object.assign(Object.assign({}, this.options), { authentication: session });
+                    return internalRequest(this.url, newOptions);
                 })
-                    .then(function (response) {
+                    .then((response) => {
                     resolve(response);
                 })
-                    .catch(function (e) {
+                    .catch((e) => {
                     if (e.name === "ArcGISAuthError" && tries < retryLimit) {
                         retryRequest(resolve, reject);
                     }
-                    else if (e.name === "ArcGISAuthError" && tries >= retryLimit) {
-                        reject(_this);
+                    else if (e.name === this.name &&
+                        e.message === this.message &&
+                        tries >= retryLimit) {
+                        reject(this);
                     }
                     else {
                         reject(e);
                     }
                 });
             };
-            return new Promise(function (resolve, reject) {
+            return new Promise((resolve, reject) => {
                 retryRequest(resolve, reject);
             });
-        };
-        return ArcGISAuthError;
-    }(ArcGISRequestError));
+        }
+    }
     /**
      * Checks for errors in a JSON response from the ArcGIS REST API. If there are no errors, it will return the `data` passed in. If there is an error, it will throw an `ArcGISRequestError` or `ArcGISAuthError`.
      *
@@ -5305,17 +5307,14 @@
     function checkForErrors(response, url, params, options, originalAuthError) {
         // this is an error message from billing.arcgis.com backend
         if (response.code >= 400) {
-            var message = response.message, code = response.code;
+            const { message, code } = response;
             throw new ArcGISRequestError(message, code, response, url, options);
         }
         // error from ArcGIS Online or an ArcGIS Portal or server instance.
         if (response.error) {
-            var _a = response.error, message = _a.message, code = _a.code, messageCode = _a.messageCode;
-            var errorCode = messageCode || code || "UNKNOWN_ERROR_CODE";
-            if (code === 498 ||
-                code === 499 ||
-                messageCode === "GWM_0003" ||
-                (code === 400 && message === "Unable to generate token.")) {
+            const { message, code, messageCode } = response.error;
+            const errorCode = messageCode || code || "UNKNOWN_ERROR_CODE";
+            if (code === 498 || code === 499) {
                 if (originalAuthError) {
                     throw originalAuthError;
                 }
@@ -5327,8 +5326,8 @@
         }
         // error from a status check
         if (response.status === "failed" || response.status === "failure") {
-            var message = void 0;
-            var code = "UNKNOWN_ERROR_CODE";
+            let message;
+            let code = "UNKNOWN_ERROR_CODE";
             try {
                 message = JSON.parse(response.statusMessage).message;
                 code = JSON.parse(response.statusMessage).code;
@@ -5341,64 +5340,29 @@
         return response;
     }
     /**
-     * ```js
-     * import { request } from '@esri/arcgis-rest-request';
-     * //
-     * request('https://www.arcgis.com/sharing/rest')
-     *   .then(response) // response.currentVersion === 5.2
-     * //
-     * request('https://www.arcgis.com/sharing/rest', {
-     *   httpMethod: "GET"
-     * })
-     * //
-     * request('https://www.arcgis.com/sharing/rest/search', {
-     *   params: { q: 'parks' }
-     * })
-     *   .then(response) // response.total => 78379
-     * ```
-     * Generic method for making HTTP requests to ArcGIS REST API endpoints.
+     * This is the internal implementation of `request` without the automatic retry behavior to prevent
+     * infinite loops when a server continues to return invalid token errors.
      *
      * @param url - The URL of the ArcGIS REST API endpoint.
      * @param requestOptions - Options for the request, including parameters relevant to the endpoint.
      * @returns A Promise that will resolve with the data from the response.
+     * @internal
      */
-    function request(url, requestOptions) {
-        if (requestOptions === void 0) { requestOptions = { params: { f: "json" } }; }
-        var options = __assign(__assign(__assign({ httpMethod: "POST" }, DEFAULT_ARCGIS_REQUEST_OPTIONS), requestOptions), {
-            params: __assign(__assign({}, DEFAULT_ARCGIS_REQUEST_OPTIONS.params), requestOptions.params),
-            headers: __assign(__assign({}, DEFAULT_ARCGIS_REQUEST_OPTIONS.headers), requestOptions.headers),
+    function internalRequest(url, requestOptions) {
+        const defaults = getDefaultRequestOptions();
+        const options = Object.assign(Object.assign(Object.assign({ httpMethod: "POST" }, defaults), requestOptions), {
+            params: Object.assign(Object.assign({}, defaults.params), requestOptions.params),
+            headers: Object.assign(Object.assign({}, defaults.headers), requestOptions.headers)
         });
-        var missingGlobals = [];
-        var recommendedPackages = [];
-        // don't check for a global fetch if a custom implementation was passed through
-        if (!options.fetch && typeof fetch !== "undefined") {
-            options.fetch = fetch.bind(Function("return this")());
-        }
-        else {
-            missingGlobals.push("`fetch`");
-            recommendedPackages.push("`node-fetch`");
-        }
-        if (typeof Promise === "undefined") {
-            missingGlobals.push("`Promise`");
-            recommendedPackages.push("`es6-promise`");
-        }
-        if (typeof FormData === "undefined") {
-            missingGlobals.push("`FormData`");
-            recommendedPackages.push("`isomorphic-form-data`");
-        }
-        if (!options.fetch ||
-            typeof Promise === "undefined" ||
-            typeof FormData === "undefined") {
-            throw new Error("`arcgis-rest-request` requires a `fetch` implementation and global variables for `Promise` and `FormData` to be present in the global scope. You are missing " + missingGlobals.join(", ") + ". We recommend installing the " + recommendedPackages.join(", ") + " modules at the root of your application to add these to the global scope. See https://bit.ly/2KNwWaJ for more info.");
-        }
-        var httpMethod = options.httpMethod, authentication = options.authentication, rawResponse = options.rawResponse;
-        var params = __assign({ f: "json" }, options.params);
-        var originalAuthError = null;
-        var fetchOptions = {
+        const { httpMethod, rawResponse } = options;
+        const params = Object.assign({ f: "json" }, options.params);
+        let originalAuthError = null;
+        const fetchOptions = {
             method: httpMethod,
+            signal: options.signal,
             /* ensures behavior mimics XMLHttpRequest.
             needed to support sending IWA cookies */
-            credentials: options.credentials || "same-origin",
+            credentials: options.credentials || "same-origin"
         };
         // the /oauth2/platformSelf route will add X-Esri-Auth-Client-Id header
         // and that request needs to send cookies cross domain
@@ -5408,8 +5372,35 @@
             url.indexOf("/oauth2/platformSelf") > -1) {
             fetchOptions.credentials = "include";
         }
+        let authentication;
+        // Check to see if this is a raw token as a string and create a IAuthenticationManager like object for it.
+        // Otherwise this just assumes that options.authentication is an IAuthenticationManager.
+        if (typeof options.authentication === "string") {
+            const rawToken = options.authentication;
+            authentication = {
+                portal: "https://www.arcgis.com/sharing/rest",
+                getToken: () => {
+                    return Promise.resolve(rawToken);
+                }
+            };
+            /* istanbul ignore else - we don't need to test NOT warning people */
+            if (!options.authentication.startsWith("AAPK") &&
+                !options.authentication.startsWith("AATK") && // doesn't look like an API Key
+                !options.suppressWarnings && // user doesn't want to suppress warnings for this request
+                !globalThis.ARCGIS_REST_JS_SUPPRESS_TOKEN_WARNING // we haven't shown the user this warning yet
+            ) {
+                warn(`Using an oAuth 2.0 access token directly in the token option is discouraged. Consider using ArcGISIdentityManager or Application session. See https://esriurl.com/arcgis-rest-js-direct-token-warning for more information.`);
+                globalThis.ARCGIS_REST_JS_SUPPRESS_TOKEN_WARNING = true;
+            }
+        }
+        else {
+            authentication = options.authentication;
+        }
+        // for errors in GET requests we want the URL passed to the error to be the URL before
+        // query params are applied.
+        const originalUrl = url;
         return (authentication
-            ? authentication.getToken(url, { fetch: options.fetch }).catch(function (err) {
+            ? authentication.getToken(url).catch((err) => {
                 /**
                  * append original request url and requestOptions
                  * to the error thrown by getToken()
@@ -5426,7 +5417,7 @@
                 return Promise.resolve("");
             })
             : Promise.resolve(""))
-            .then(function (token) {
+            .then((token) => {
             if (token.length) {
                 params.token = token;
             }
@@ -5434,7 +5425,7 @@
                 fetchOptions.credentials = authentication.getDomainCredentials(url);
             }
             // Custom headers to add to request. IRequestOptions.headers with merge over requestHeaders.
-            var requestHeaders = {};
+            const requestHeaders = {};
             if (fetchOptions.method === "GET") {
                 // Prevents token from being passed in query params when hideToken option is used.
                 /* istanbul ignore if - window is always defined in a browser. Test case is covered by Jasmine in node test */
@@ -5442,13 +5433,13 @@
                     options.hideToken &&
                     // Sharing API does not support preflight check required by modern browsers https://developer.mozilla.org/en-US/docs/Glossary/Preflight_request
                     typeof window === "undefined") {
-                    requestHeaders["X-Esri-Authorization"] = "Bearer " + params.token;
+                    requestHeaders["X-Esri-Authorization"] = `Bearer ${params.token}`;
                     delete params.token;
                 }
                 // encode the parameters into the query string
-                var queryParams = encodeQueryString(params);
+                const queryParams = encodeQueryString(params);
                 // dont append a '?' unless parameters are actually present
-                var urlWithQueryString = queryParams === "" ? url : url + "?" + encodeQueryString(params);
+                const urlWithQueryString = queryParams === "" ? url : url + "?" + encodeQueryString(params);
                 if (
                 // This would exceed the maximum length for URLs specified by the consumer and requires POST
                 (options.maxUrlLength &&
@@ -5473,14 +5464,18 @@
             /* updateResources currently requires FormData even when the input parameters dont warrant it.
         https://developers.arcgis.com/rest/users-groups-and-items/update-resources.htm
             see https://github.com/Esri/arcgis-rest-js/pull/500 for more info. */
-            var forceFormData = new RegExp("/items/.+/updateResources").test(url);
+            const forceFormData = new RegExp("/items/.+/updateResources").test(url);
             if (fetchOptions.method === "POST") {
                 fetchOptions.body = encodeFormData(params, forceFormData);
             }
             // Mixin headers from request options
-            fetchOptions.headers = __assign(__assign({}, requestHeaders), options.headers);
+            fetchOptions.headers = Object.assign(Object.assign({}, requestHeaders), options.headers);
+            // This should have the same conditional for Node JS as ArcGISIdentityManager.refreshWithUsernameAndPassword()
+            // to ensure that generated tokens have the same referer when used in Node with a username and password.
             /* istanbul ignore next - karma reports coverage on browser tests only */
-            if (typeof window === "undefined" && !fetchOptions.headers.referer) {
+            if ((typeof window === "undefined" ||
+                (window && typeof window.document === "undefined")) &&
+                !fetchOptions.headers.referer) {
                 fetchOptions.headers.referer = NODEJS_DEFAULT_REFERER_HEADER;
             }
             /* istanbul ignore else blob responses are difficult to make cross platform we will just have to trust the isomorphic fetch will do its job */
@@ -5488,13 +5483,40 @@
                 fetchOptions.headers["Content-Type"] =
                     "application/x-www-form-urlencoded";
             }
-            return options.fetch(url, fetchOptions);
+            /**
+             * Check for a global fetch first and use it if available. This allows us to use the default
+             * configuration of fetch-mock in tests.
+             */
+            /* istanbul ignore next coverage is based on browser code and we don't test for the absence of global fetch so we can skip the else here. */
+            return globalThis.fetch
+                ? globalThis.fetch(url, fetchOptions)
+                : getFetch().then(({ fetch }) => {
+                    return fetch(url, fetchOptions);
+                });
         })
-            .then(function (response) {
+            .then((response) => {
+            // the request got back an error status code (4xx, 5xx)
             if (!response.ok) {
-                // server responded w/ an actual error (404, 500, etc)
-                var status_1 = response.status, statusText = response.statusText;
-                throw new ArcGISRequestError(statusText, "HTTP " + status_1, response, url, options);
+                // we need to determine if the server returned a JSON body with more details.
+                // this is the format used by newer services such as the Places and Style service.
+                return response
+                    .json()
+                    .then((jsonError) => {
+                    // The body can be parsed as JSON
+                    const { status, statusText } = response;
+                    const { message, details } = jsonError.error;
+                    const formattedMessage = `${message}. ${details ? details.join(" ") : ""}`.trim();
+                    throw new ArcGISRequestError(formattedMessage, `HTTP ${status} ${statusText}`, jsonError, url, options);
+                })
+                    .catch((e) => {
+                    // if we already were about to format this as an ArcGISRequestError throw that error
+                    if (e.name === "ArcGISRequestError") {
+                        throw e;
+                    }
+                    // server responded w/ an actual error (404, 500, etc) but we could not parse it as JSON
+                    const { status, statusText } = response;
+                    throw new ArcGISRequestError(statusText, `HTTP ${status}`, response, url, options);
+                });
             }
             if (rawResponse) {
                 return response;
@@ -5513,21 +5535,23 @@
                     return response.blob();
             }
         })
-            .then(function (data) {
+            .then((data) => {
+            // Check for an error in the JSON body of a successful response.
+            // Most ArcGIS Server services will return a successful status code but include an error in the response body.
             if ((params.f === "json" || params.f === "geojson") && !rawResponse) {
-                var response = checkForErrors(data, url, params, options, originalAuthError);
+                const response = checkForErrors(data, originalUrl, params, options, originalAuthError);
                 if (originalAuthError) {
                     /* If the request was made to an unfederated service that
                     didn't require authentication, add the base url and a dummy token
                     to the list of trusted servers to avoid another federation check
                     in the event of a repeat request */
-                    var truncatedUrl = url
+                    const truncatedUrl = url
                         .toLowerCase()
                         .split(/\/rest(\/admin)?\/services\//)[0];
                     options.authentication.federatedServers[truncatedUrl] = {
                         token: [],
                         // default to 24 hours
-                        expires: new Date(Date.now() + 86400 * 1000),
+                        expires: new Date(Date.now() + 86400 * 1000)
                     };
                     originalAuthError = null;
                 }
@@ -5538,6 +5562,45 @@
             }
         });
     }
+    /**
+     * Generic method for making HTTP requests to ArcGIS REST API endpoints.
+     *
+     * ```js
+     * import { request } from '@esri/arcgis-rest-request';
+     *
+     * request('https://www.arcgis.com/sharing/rest')
+     *   .then(response) // response.currentVersion === 5.2
+     *
+     * request('https://www.arcgis.com/sharing/rest', {
+     *   httpMethod: "GET"
+     * })
+     *
+     * request('https://www.arcgis.com/sharing/rest/search', {
+     *   params: { q: 'parks' }
+     * })
+     *   .then(response) // response.total => 78379
+     * ```
+     *
+     * @param url - The URL of the ArcGIS REST API endpoint.
+     * @param requestOptions - Options for the request, including parameters relevant to the endpoint.
+     * @returns A Promise that will resolve with the data from the response.
+     */
+    function request(url, requestOptions = { params: { f: "json" } }) {
+        return internalRequest(url, requestOptions).catch((e) => {
+            if (e instanceof ArcGISAuthError &&
+                requestOptions.authentication &&
+                typeof requestOptions.authentication !== "string" &&
+                requestOptions.authentication.canRefresh &&
+                requestOptions.authentication.refreshCredentials) {
+                return e.retry(() => {
+                    return requestOptions.authentication.refreshCredentials();
+                }, 1);
+            }
+            else {
+                return Promise.reject(e);
+            }
+        });
+    }
 
     /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
@@ -5568,14 +5631,14 @@
      * @param requestOptions - Request options that may have authentication manager
      * @returns Portal url to be used in API requests
      */
-    function getPortalUrl(requestOptions) {
-        if (requestOptions === void 0) { requestOptions = {}; }
+    function getPortalUrl(requestOptions = {}) {
         // use portal in options if specified
         if (requestOptions.portal) {
             return cleanUrl(requestOptions.portal);
         }
         // if auth was passed, use that portal
-        if (requestOptions.authentication) {
+        if (requestOptions.authentication &&
+            typeof requestOptions.authentication !== "string") {
             // the portal url is already scrubbed in the auth package
             return requestOptions.authentication.portal;
         }
@@ -5585,27 +5648,6 @@
 
     /* Copyright (c) 2017-2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
-    /**
-     * Serialize an item and its data into a json format accepted by the Portal API for create and update operations
-     *
-     * @param item Item to be serialized
-     * @returns a formatted json object to be sent to Portal
-     */
-    function serializeItem(item) {
-        // create a clone so we're not messing with the original
-        var clone = JSON.parse(JSON.stringify(item));
-        // binary data needs POSTed as a `file`
-        // JSON object literals should be passed as `text`.
-        if (clone.data) {
-            (typeof Blob !== "undefined" && item.data instanceof Blob) ||
-                // Node.js doesn't implement Blob
-                item.data.constructor.name === "ReadStream"
-                ? (clone.file = item.data)
-                : (clone.text = item.data);
-            delete clone.data;
-        }
-        return clone;
-    }
     /**
      * `requestOptions.owner` is given priority, `requestOptions.item.owner` will be checked next. If neither are present, `authentication.getUserName()` will be used instead.
      */
@@ -5647,9 +5689,11 @@
     /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
     /**
+     * Update an Item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/update-item.htm) for more information.
+     *
      * ```js
      * import { updateItem } from "@esri/arcgis-rest-portal";
-     * //
+     *
      * updateItem({
      *   item: {
      *     id: "3ef",
@@ -5659,18 +5703,17 @@
      * })
      *   .then(response)
      * ```
-     * Update an Item. See the [REST Documentation](https://developers.arcgis.com/rest/users-groups-and-items/update-item.htm) for more information.
      *
      * @param requestOptions - Options for the request.
      * @returns A Promise that updates an item.
      */
     function updateItem(requestOptions) {
-        return determineOwner(requestOptions).then(function (owner) {
-            var url = requestOptions.folderId
-                ? getPortalUrl(requestOptions) + "/content/users/" + owner + "/" + requestOptions.folderId + "/items/" + requestOptions.item.id + "/update"
-                : getPortalUrl(requestOptions) + "/content/users/" + owner + "/items/" + requestOptions.item.id + "/update";
+        return determineOwner(requestOptions).then((owner) => {
+            const url = requestOptions.folderId
+                ? `${getPortalUrl(requestOptions)}/content/users/${owner}/${requestOptions.folderId}/items/${requestOptions.item.id}/update`
+                : `${getPortalUrl(requestOptions)}/content/users/${owner}/items/${requestOptions.item.id}/update`;
             // serialize the item into something Portal will accept
-            requestOptions.params = __assign$1(__assign$1({}, requestOptions.params), serializeItem(requestOptions.item));
+            requestOptions.params = Object.assign(Object.assign({}, requestOptions.params), requestOptions.item);
             // convert extent, if present, into a string from bbox
             // processParams was previously doing this sort of work,
             // however now we need to let array of arrays through
@@ -5701,9 +5744,9 @@
      * @returns A Promise that will resolve with the data from the response.
      */
     function getItem(id, requestOptions) {
-        var url = getItemBaseUrl(id, requestOptions);
+        const url = getItemBaseUrl(id, requestOptions);
         // default to a GET request
-        var options = __assign$1({ httpMethod: "GET" }, requestOptions);
+        const options = Object.assign({ httpMethod: "GET" }, requestOptions);
         return request(url, options);
     }
     /**
@@ -5712,11 +5755,11 @@
      * @param portalUrlOrRequestOptions a portal URL or request options
      * @returns URL to the item's REST end point, defaults to `https://www.arcgis.com/sharing/rest/content/items/{id}`
      */
-    var getItemBaseUrl = function (id, portalUrlOrRequestOptions) {
-        var portalUrl = typeof portalUrlOrRequestOptions === "string"
+    const getItemBaseUrl = (id, portalUrlOrRequestOptions) => {
+        const portalUrl = typeof portalUrlOrRequestOptions === "string"
             ? portalUrlOrRequestOptions
             : getPortalUrl(portalUrlOrRequestOptions);
-        return portalUrl + "/content/items/" + id;
+        return `${portalUrl}/content/items/${id}`;
     };
 
     function buildAccessProperties(username, currentAccessProperties, accessChangeset) {