@esri/telemetry-amazon 6.0.0-beta.0 → 6.0.0-beta.10

package/dist/umd/telemetry-amazon.js

@@ -8,115 +8,86 @@
 
     var awsPinpointPlugin__default = /*#__PURE__*/_interopDefaultLegacy(awsPinpointPlugin);
 
-    const storage = {
-        storage: {},
-        memory: true,
-        get(key) {
-            let stored;
-            try {
-                stored =
-                    (window.localStorage && window.localStorage.getItem(key)) ||
-                        this.storage[key];
-            }
-            catch (e) {
-                stored = this.storage[key];
-            }
-            if (stored) {
-                try {
-                    return JSON.parse(stored);
-                }
-                catch (e) {
-                    return undefined;
-                }
-            }
-            else {
-                return undefined;
-            }
-        },
-        set(key, value) {
-            // handle Safari private mode (setItem is not allowed)
-            const valueToString = JSON.stringify(value);
-            try {
-                window.localStorage.setItem(key, valueToString);
-            }
-            catch (e) {
-                if (!this.memory) {
-                    console.error('setting local storage failed, falling back to in-memory storage');
-                    this.memory = true;
-                }
-                this.storage[key] = value;
-            }
-        },
-        delete(key) {
-            try {
-                window.localStorage.removeItem(key);
-            }
-            catch (e) {
-                if (!this.memory) {
-                    console.error('setting local storage failed, falling back to in-memory storage');
-                    this.memory = true;
-                }
-                delete this.storage[key];
-            }
-        },
-    };
+    const AMAZON_EVENT_ATTRIBUTE_KEYS = [
+        'action',
+        'attribute',
+        'category',
+        'datasetId',
+        'details',
+        'error',
+        'facetValue',
+        'hostname',
+        'json',
+        'label',
+        'lastLogin',
+        'objectId',
+        'org',
+        'pageUrl',
+        'path',
+        'pageName',
+        'previousPageName',
+        'previousPageUrl',
+        'referrer',
+        'searchQuery',
+        'serviceQuery',
+        'statusCode',
+        'user',
+        'userSince',
+        'urlRequested',
+        'internalUser',
+        'accountType',
+        'workflowId',
+        'browserWebCapabilities',
+        /**
+         * Original plan was to union this in as `AmazonDimensionKey`, but it's strictly defined in the schema that there are 20 dimensions
+         * so a little non-DRY is fine for readability's sake
+         */
+        'dimension1',
+        'dimension2',
+        'dimension3',
+        'dimension4',
+        'dimension5',
+        'dimension6',
+        'dimension7',
+        'dimension8',
+        'dimension9',
+        'dimension10',
+        'dimension11',
+        'dimension12',
+        'dimension13',
+        'dimension14',
+        'dimension15',
+        'dimension16',
+        'dimension17',
+        'dimension18',
+        'dimension19',
+        'dimension20',
+        /**
+         * NOTE: `eventType` is NOT an attribute, but instead a core property on the telemetry payload. Many apps have been treating it
+         * as an attribute though, so it's included here for backwards compatibility. Internally it is re-mapped to `eventType`, where all other attributes
+         * are mapped to `a_attributeName` in the telemetry payload. This is a known issue and will be addressed in a future release.
+         */
+        'eventType',
+        /**
+         * NOTE: `pathname` is NOT an attribute, nor an official property at all. It is internally mapped to `path`, but is used interchangeably by consuming apps.
+         * It's included here for backwards compatibility, but should not be used in new telemetry events. If `path` is set, this will never be used.
+         */
+        'pathname',
+    ];
 
-    const COGNITO_KEY = 'TELEMETRY_COGNITO_CREDENTIALS';
-    function getCredentials(IdentityPoolId, options = {}) {
-        const fipsSubdomainSuffix = options.fips === true ? '-fips' : '';
-        const COGNITO_URL = `https://cognito-identity${fipsSubdomainSuffix}.us-east-1.amazonaws.com/`;
-        let cached = storage.get(COGNITO_KEY);
-        if (cached && Date.now() / 1000 < cached.Expiration)
-            return Promise.resolve(cached);
-        const fetchOptions = {
-            method: 'POST',
-            headers: {
-                'Content-type': 'application/x-amz-json-1.1',
-                'X-Amz-Target': 'AWSCognitoIdentityService.GetId',
-            },
-            body: JSON.stringify({ IdentityPoolId }),
-        };
-        return fetch(COGNITO_URL, fetchOptions)
-            .then((response) => {
-            if (!response.ok) {
-                throw new Error(response.statusText);
-            }
-            return response.json();
-        })
-            .then((response) => {
-            const { IdentityId } = response;
-            const options = {
-                method: 'POST',
-                headers: {
-                    'Content-type': 'application/x-amz-json-1.1',
-                    'X-Amz-Target': 'AWSCognitoIdentityService.GetCredentialsForIdentity',
-                },
-                body: JSON.stringify({ IdentityId }),
-            };
-            return fetch(COGNITO_URL, options);
-        })
-            .then((response) => {
-            if (!response.ok) {
-                throw new Error(response.statusText);
-            }
-            return response.json();
-        })
-            .then(({ Credentials }) => {
-            storage.set(COGNITO_KEY, Credentials);
-            return Credentials;
-        });
+    function isAmazonEventAttributeKey(key) {
+        return AMAZON_EVENT_ATTRIBUTE_KEYS.includes(key);
     }
-
-    function formatTelemetryAttributes({ telemetryData, dimensionLookup = {}, excludeKeys = [], }) {
+    function formatTelemetryAttributes({ telemetryData, dimensionLookup = {}, }) {
         return Object.keys(telemetryData)
             .filter((key) => {
-            return !excludeKeys.includes(key);
+            return isAmazonEventAttributeKey(key);
         })
             .map((key) => {
             if (dimensionLookup[key]) {
                 return {
                     key: getCustomDimensionKey(dimensionLookup, key),
-                    value: telemetryData[key],
+                    value: getValue(telemetryData, key),
                 };
             }
             return {
@@ -133,7 +104,7 @@
         if (key === 'json') {
             return data[key] ? JSON.stringify(data[key]) : 'null';
         }
-        return data[key] === undefined ? 'null' : data[key].toString();
+        return data[key] === undefined ? 'null' : String(data[key]);
     }
     function getCustomDimensionKey(lookup, key) {
         return `dimension${lookup[key]}`;
@@ -167,31 +138,30 @@
     }
 
     function createEventLog({ event = {}, dimensionLookup = {}, metricLookup = {}, }) {
-        var _a, _b;
+        var _a, _b, _c;
+        const acceptedAttributeKeys = new Set(AMAZON_EVENT_ATTRIBUTE_KEYS);
         const { pathname: eventPathname, eventType = 'other' } = event;
         const metrics = formatTelemetryMetrics(event, metricLookup);
-        const eventAttributes = formatTelemetryAttributes({
-            telemetryData: Object.assign({ eventType }, event),
+        const formattedEventAttributes = formatTelemetryAttributes({
+            telemetryData: Object.assign({}, event),
             dimensionLookup,
-            excludeKeys: [
-                'workflow',
-                'pathname',
-                ...Object.keys(metrics),
-                ...Object.keys(metricLookup),
-            ],
         });
-        const telemetryPayload = Object.assign(Object.assign({ name: eventType }, eventAttributes), metrics);
+        const eventAttributes = Object.fromEntries(Object.entries(formattedEventAttributes).filter(([key]) => {
+            return acceptedAttributeKeys.has(key);
+        }));
+        const telemetryPayload = Object.assign(Object.assign(Object.assign({}, eventAttributes), metrics), { name: eventType });
         // Set browser properties if available
-        if (typeof document !== 'undefined' && document.referrer) {
+        if (typeof document !== 'undefined' &&
+            document.referrer &&
+            !telemetryPayload.referrer) {
             telemetryPayload.referrer = document.referrer;
         }
         if (typeof window !== 'undefined' && !telemetryPayload.hostname) {
             telemetryPayload.hostname = (_a = window.location) === null || _a === void 0 ? void 0 : _a.hostname;
         }
-        telemetryPayload.path =
-            typeof window !== 'undefined' && window.location.pathname
-                ? (_b = window.location) === null || _b === void 0 ? void 0 : _b.pathname
-                : eventPathname;
+        (_b = telemetryPayload.path) !== null && _b !== void 0 ? _b : (telemetryPayload.path = typeof window !== 'undefined' && window.location.pathname
+            ? (_c = window.location) === null || _c === void 0 ? void 0 : _c.pathname
+            : eventPathname);
         return telemetryPayload;
     }
 
@@ -200,16 +170,11 @@
         const attributes = formatTelemetryAttributes({
             telemetryData: options,
             dimensionLookup,
-            excludeKeys: [
-                'workflow',
-                ...Object.keys(metrics),
-                ...Object.keys(metricLookup),
-            ],
         });
         const { referrer, title } = document || {};
         const { hostname, pathname } = window && window.location ? window.location : {};
         return Object.assign(Object.assign({ name: 'pageView', referrer,
-            hostname, path: page || pathname, pageUrl: page || pathname, pageName: title, previousPageUrl: previousPage.pageUrl, previousPageName: previousPage.pageName }, attributes), metrics);
+            hostname, path: page || pathname, pageUrl: page || pathname, pageName: title, previousPageUrl: previousPage === null || previousPage === void 0 ? void 0 : previousPage.pageUrl, previousPageName: previousPage === null || previousPage === void 0 ? void 0 : previousPage.pageName }, attributes), metrics);
     }
 
     var dlv_umd = {exports: {}};
@@ -288,6 +253,96 @@
       return De(_objectSpread2(_objectSpread2({}, defaultSettings), opts));
     }
 
+    const storage = {
+        storage: {},
+        memory: true,
+        get(key) {
+            let stored;
+            try {
+                stored =
+                    (window.localStorage && window.localStorage.getItem(key)) ||
+                        this.storage[key];
+            }
+            catch (e) {
+                stored = this.storage[key];
+            }
+            if (stored) {
+                try {
+                    return JSON.parse(stored);
+                }
+                catch (e) {
+                    return undefined;
+                }
+            }
+            else {
+                return undefined;
+            }
+        },
+        set(key, value) {
+            // handle Safari private mode (setItem is not allowed)
+            const valueToString = JSON.stringify(value);
+            try {
+                window.localStorage.setItem(key, valueToString);
+            }
+            catch (e) {
+                if (!this.memory) {
+                    console.error('setting local storage failed, falling back to in-memory storage');
+                    this.memory = true;
+                }
+                this.storage[key] = value;
+            }
+        },
+        delete(key) {
+            try {
+                window.localStorage.removeItem(key);
+            }
+            catch (e) {
+                if (!this.memory) {
+                    console.error('setting local storage failed, falling back to in-memory storage');
+                    this.memory = true;
+                }
+                delete this.storage[key];
+            }
+        },
+    };
+
+    const COGNITO_KEY = 'TELEMETRY_COGNITO_CREDENTIALS';
+    async function getCredentials(IdentityPoolId, options = {}) {
+        const fipsSubdomainSuffix = options.fips === true ? '-fips' : '';
+        const COGNITO_URL = `https://cognito-identity${fipsSubdomainSuffix}.us-east-1.amazonaws.com/`;
+        let cached = storage.get(COGNITO_KEY);
+        if (cached && Date.now() / 1000 < cached.Expiration)
+            return cached;
+        const fetchOptions = {
+            method: 'POST',
+            headers: {
+                'Content-type': 'application/x-amz-json-1.1',
+                'X-Amz-Target': 'AWSCognitoIdentityService.GetId',
+            },
+            body: JSON.stringify({ IdentityPoolId }),
+        };
+        const getIdResponse = await fetch(COGNITO_URL, fetchOptions);
+        if (!getIdResponse.ok) {
+            throw new Error(getIdResponse.statusText);
+        }
+        const { IdentityId } = await getIdResponse.json();
+        const credentialsOptions = {
+            method: 'POST',
+            headers: {
+                'Content-type': 'application/x-amz-json-1.1',
+                'X-Amz-Target': 'AWSCognitoIdentityService.GetCredentialsForIdentity',
+            },
+            body: JSON.stringify({ IdentityId }),
+        };
+        const getCredentialsResponse = await fetch(COGNITO_URL, credentialsOptions);
+        if (!getCredentialsResponse.ok) {
+            throw new Error(getCredentialsResponse.statusText);
+        }
+        const { Credentials } = await getCredentialsResponse.json();
+        storage.set(COGNITO_KEY, Credentials);
+        return Credentials;
+    }
+
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -1259,6 +1314,26 @@
     function bboxToString(extent) {
         return extent.join(",");
     }
+    /**
+     * Returns the full thumbnail URL for an item.
+     *
+     * @param item - The item to decorate
+     * @param portal - The portal URL
+     * @param token - Optional token to append if the item is private
+     * @returns The item with decorated thumbnail
+     */
+    function decorateThumbnail(item, portal, token) {
+        if (!item)
+            return item;
+        let thumbnailUrl = null;
+        if (typeof item.thumbnail === "string") {
+            thumbnailUrl = `${portal}/content/items/${item.id}/info/${item.thumbnail}`;
+            if (thumbnailUrl && item.access !== "public" && token) {
+                thumbnailUrl += `?${token}`;
+            }
+        }
+        return Object.assign(Object.assign({}, item), (thumbnailUrl ? { thumbnailUrl } : {}));
+    }
 
     /* Copyright (c) 2018 Environmental Systems Research Institute, Inc.
      * Apache-2.0 */
@@ -1295,6 +1370,16 @@
             if (requestOptions.params.extent && isBBox(requestOptions.params.extent)) {
                 requestOptions.params.extent = bboxToString(requestOptions.params.extent);
             }
+            const portal = getPortalUrl(requestOptions);
+            const decoratedThumbnail = decorateThumbnail(Object.assign(Object.assign({}, requestOptions.item), { access: requestOptions.item.access }), portal);
+            const paramsThumbnailUrl = requestOptions.params.thumbnailUrl;
+            if (typeof decoratedThumbnail.thumbnailUrl === "string" &&
+                typeof paramsThumbnailUrl === "string") {
+                if (decoratedThumbnail.thumbnailUrl.split("?")[0] ===
+                    paramsThumbnailUrl.split("?")[0]) {
+                    delete requestOptions.params.thumbnailUrl;
+                }
+            }
             return request(url, requestOptions);
         });
     }
@@ -1321,7 +1406,22 @@
         const url = getItemBaseUrl(id, requestOptions);
         // default to a GET request
         const options = Object.assign({ httpMethod: "GET" }, requestOptions);
-        return request(url, options);
+        return request(url, options).then(async (item) => {
+            const portal = (requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.portal) || getPortalUrl(requestOptions);
+            let token;
+            // if authentication is provided and it’s an authentication manager and the item is not public then request a token for secure access
+            if ((requestOptions === null || requestOptions === void 0 ? void 0 : requestOptions.authentication) &&
+                typeof requestOptions.authentication !== "string" &&
+                item.access !== "public") {
+                try {
+                    token = await requestOptions.authentication.getToken(url);
+                }
+                catch (e) {
+                    // Ignore token acquisition errors because `getToken()` can fail for some authentication types, but we still want to return the item info when possible since the browser may still provide thumbnail access via an auth cookie.
+                }
+            }
+            return decorateThumbnail(item, portal, token);
+        });
     }
     /**
      * Get the fully qualified base URL to the REST end point for an item.
@@ -1376,29 +1476,1039 @@
         return { access };
     }
 
+    /**
+     * @license MIT <https://opensource.org/licenses/MIT>
+     * @copyright Michael Hart 2024
+     */
+    const encoder = new TextEncoder();
+    const HOST_SERVICES = {
+      appstream2: 'appstream',
+      cloudhsmv2: 'cloudhsm',
+      email: 'ses',
+      marketplace: 'aws-marketplace',
+      mobile: 'AWSMobileHubService',
+      pinpoint: 'mobiletargeting',
+      queue: 'sqs',
+      'git-codecommit': 'codecommit',
+      'mturk-requester-sandbox': 'mturk-requester',
+      'personalize-runtime': 'personalize',
+    };
+    const UNSIGNABLE_HEADERS = new Set([
+      'authorization',
+      'content-type',
+      'content-length',
+      'user-agent',
+      'presigned-expires',
+      'expect',
+      'x-amzn-trace-id',
+      'range',
+      'connection',
+    ]);
+    class AwsClient {
+      constructor({ accessKeyId, secretAccessKey, sessionToken, service, region, cache, retries, initRetryMs }) {
+        if (accessKeyId == null) throw new TypeError('accessKeyId is a required option')
+        if (secretAccessKey == null) throw new TypeError('secretAccessKey is a required option')
+        this.accessKeyId = accessKeyId;
+        this.secretAccessKey = secretAccessKey;
+        this.sessionToken = sessionToken;
+        this.service = service;
+        this.region = region;
+        this.cache = cache || new Map();
+        this.retries = retries != null ? retries : 10;
+        this.initRetryMs = initRetryMs || 50;
+      }
+      async sign(input, init) {
+        if (input instanceof Request) {
+          const { method, url, headers, body } = input;
+          init = Object.assign({ method, url, headers }, init);
+          if (init.body == null && headers.has('Content-Type')) {
+            init.body = body != null && headers.has('X-Amz-Content-Sha256') ? body : await input.clone().arrayBuffer();
+          }
+          input = url;
+        }
+        const signer = new AwsV4Signer(Object.assign({ url: input.toString() }, init, this, init && init.aws));
+        const signed = Object.assign({}, init, await signer.sign());
+        delete signed.aws;
+        try {
+          return new Request(signed.url.toString(), signed)
+        } catch (e) {
+          if (e instanceof TypeError) {
+            return new Request(signed.url.toString(), Object.assign({ duplex: 'half' }, signed))
+          }
+          throw e
+        }
+      }
+      async fetch(input, init) {
+        for (let i = 0; i <= this.retries; i++) {
+          const fetched = fetch(await this.sign(input, init));
+          if (i === this.retries) {
+            return fetched
+          }
+          const res = await fetched;
+          if (res.status < 500 && res.status !== 429) {
+            return res
+          }
+          await new Promise(resolve => setTimeout(resolve, Math.random() * this.initRetryMs * Math.pow(2, i)));
+        }
+        throw new Error('An unknown error occurred, ensure retries is not negative')
+      }
+    }
+    class AwsV4Signer {
+      constructor({ method, url, headers, body, accessKeyId, secretAccessKey, sessionToken, service, region, cache, datetime, signQuery, appendSessionToken, allHeaders, singleEncode }) {
+        if (url == null) throw new TypeError('url is a required option')
+        if (accessKeyId == null) throw new TypeError('accessKeyId is a required option')
+        if (secretAccessKey == null) throw new TypeError('secretAccessKey is a required option')
+        this.method = method || (body ? 'POST' : 'GET');
+        this.url = new URL(url);
+        this.headers = new Headers(headers || {});
+        this.body = body;
+        this.accessKeyId = accessKeyId;
+        this.secretAccessKey = secretAccessKey;
+        this.sessionToken = sessionToken;
+        let guessedService, guessedRegion;
+        if (!service || !region) {
+    [guessedService, guessedRegion] = guessServiceRegion(this.url, this.headers);
+        }
+        this.service = service || guessedService || '';
+        this.region = region || guessedRegion || 'us-east-1';
+        this.cache = cache || new Map();
+        this.datetime = datetime || new Date().toISOString().replace(/[:-]|\.\d{3}/g, '');
+        this.signQuery = signQuery;
+        this.appendSessionToken = appendSessionToken || this.service === 'iotdevicegateway';
+        this.headers.delete('Host');
+        if (this.service === 's3' && !this.signQuery && !this.headers.has('X-Amz-Content-Sha256')) {
+          this.headers.set('X-Amz-Content-Sha256', 'UNSIGNED-PAYLOAD');
+        }
+        const params = this.signQuery ? this.url.searchParams : this.headers;
+        params.set('X-Amz-Date', this.datetime);
+        if (this.sessionToken && !this.appendSessionToken) {
+          params.set('X-Amz-Security-Token', this.sessionToken);
+        }
+        this.signableHeaders = ['host', ...this.headers.keys()]
+          .filter(header => allHeaders || !UNSIGNABLE_HEADERS.has(header))
+          .sort();
+        this.signedHeaders = this.signableHeaders.join(';');
+        this.canonicalHeaders = this.signableHeaders
+          .map(header => header + ':' + (header === 'host' ? this.url.host : (this.headers.get(header) || '').replace(/\s+/g, ' ')))
+          .join('\n');
+        this.credentialString = [this.datetime.slice(0, 8), this.region, this.service, 'aws4_request'].join('/');
+        if (this.signQuery) {
+          if (this.service === 's3' && !params.has('X-Amz-Expires')) {
+            params.set('X-Amz-Expires', '86400');
+          }
+          params.set('X-Amz-Algorithm', 'AWS4-HMAC-SHA256');
+          params.set('X-Amz-Credential', this.accessKeyId + '/' + this.credentialString);
+          params.set('X-Amz-SignedHeaders', this.signedHeaders);
+        }
+        if (this.service === 's3') {
+          try {
+            this.encodedPath = decodeURIComponent(this.url.pathname.replace(/\+/g, ' '));
+          } catch (e) {
+            this.encodedPath = this.url.pathname;
+          }
+        } else {
+          this.encodedPath = this.url.pathname.replace(/\/+/g, '/');
+        }
+        if (!singleEncode) {
+          this.encodedPath = encodeURIComponent(this.encodedPath).replace(/%2F/g, '/');
+        }
+        this.encodedPath = encodeRfc3986(this.encodedPath);
+        const seenKeys = new Set();
+        this.encodedSearch = [...this.url.searchParams]
+          .filter(([k]) => {
+            if (!k) return false
+            if (this.service === 's3') {
+              if (seenKeys.has(k)) return false
+              seenKeys.add(k);
+            }
+            return true
+          })
+          .map(pair => pair.map(p => encodeRfc3986(encodeURIComponent(p))))
+          .sort(([k1, v1], [k2, v2]) => k1 < k2 ? -1 : k1 > k2 ? 1 : v1 < v2 ? -1 : v1 > v2 ? 1 : 0)
+          .map(pair => pair.join('='))
+          .join('&');
+      }
+      async sign() {
+        if (this.signQuery) {
+          this.url.searchParams.set('X-Amz-Signature', await this.signature());
+          if (this.sessionToken && this.appendSessionToken) {
+            this.url.searchParams.set('X-Amz-Security-Token', this.sessionToken);
+          }
+        } else {
+          this.headers.set('Authorization', await this.authHeader());
+        }
+        return {
+          method: this.method,
+          url: this.url,
+          headers: this.headers,
+          body: this.body,
+        }
+      }
+      async authHeader() {
+        return [
+          'AWS4-HMAC-SHA256 Credential=' + this.accessKeyId + '/' + this.credentialString,
+          'SignedHeaders=' + this.signedHeaders,
+          'Signature=' + (await this.signature()),
+        ].join(', ')
+      }
+      async signature() {
+        const date = this.datetime.slice(0, 8);
+        const cacheKey = [this.secretAccessKey, date, this.region, this.service].join();
+        let kCredentials = this.cache.get(cacheKey);
+        if (!kCredentials) {
+          const kDate = await hmac('AWS4' + this.secretAccessKey, date);
+          const kRegion = await hmac(kDate, this.region);
+          const kService = await hmac(kRegion, this.service);
+          kCredentials = await hmac(kService, 'aws4_request');
+          this.cache.set(cacheKey, kCredentials);
+        }
+        return buf2hex(await hmac(kCredentials, await this.stringToSign()))
+      }
+      async stringToSign() {
+        return [
+          'AWS4-HMAC-SHA256',
+          this.datetime,
+          this.credentialString,
+          buf2hex(await hash(await this.canonicalString())),
+        ].join('\n')
+      }
+      async canonicalString() {
+        return [
+          this.method.toUpperCase(),
+          this.encodedPath,
+          this.encodedSearch,
+          this.canonicalHeaders + '\n',
+          this.signedHeaders,
+          await this.hexBodyHash(),
+        ].join('\n')
+      }
+      async hexBodyHash() {
+        let hashHeader = this.headers.get('X-Amz-Content-Sha256') || (this.service === 's3' && this.signQuery ? 'UNSIGNED-PAYLOAD' : null);
+        if (hashHeader == null) {
+          if (this.body && typeof this.body !== 'string' && !('byteLength' in this.body)) {
+            throw new Error('body must be a string, ArrayBuffer or ArrayBufferView, unless you include the X-Amz-Content-Sha256 header')
+          }
+          hashHeader = buf2hex(await hash(this.body || ''));
+        }
+        return hashHeader
+      }
+    }
+    async function hmac(key, string) {
+      const cryptoKey = await crypto.subtle.importKey(
+        'raw',
+        typeof key === 'string' ? encoder.encode(key) : key,
+        { name: 'HMAC', hash: { name: 'SHA-256' } },
+        false,
+        ['sign'],
+      );
+      return crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(string))
+    }
+    async function hash(content) {
+      return crypto.subtle.digest('SHA-256', typeof content === 'string' ? encoder.encode(content) : content)
+    }
+    const HEX_CHARS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
+    function buf2hex(arrayBuffer) {
+      const buffer = new Uint8Array(arrayBuffer);
+      let out = '';
+      for (let idx = 0; idx < buffer.length; idx++) {
+        const n = buffer[idx];
+        out += HEX_CHARS[(n >>> 4) & 0xF];
+        out += HEX_CHARS[n & 0xF];
+      }
+      return out
+    }
+    function encodeRfc3986(urlEncodedStr) {
+      return urlEncodedStr.replace(/[!'()*]/g, c => '%' + c.charCodeAt(0).toString(16).toUpperCase())
+    }
+    function guessServiceRegion(url, headers) {
+      const { hostname, pathname } = url;
+      if (hostname.endsWith('.on.aws')) {
+        const match = hostname.match(/^[^.]{1,63}\.lambda-url\.([^.]{1,63})\.on\.aws$/);
+        return match != null ? ['lambda', match[1] || ''] : ['', '']
+      }
+      if (hostname.endsWith('.r2.cloudflarestorage.com')) {
+        return ['s3', 'auto']
+      }
+      if (hostname.endsWith('.backblazeb2.com')) {
+        const match = hostname.match(/^(?:[^.]{1,63}\.)?s3\.([^.]{1,63})\.backblazeb2\.com$/);
+        return match != null ? ['s3', match[1] || ''] : ['', '']
+      }
+      const match = hostname.replace('dualstack.', '').match(/([^.]{1,63})\.(?:([^.]{0,63})\.)?amazonaws\.com(?:\.cn)?$/);
+      let service = (match && match[1]) || '';
+      let region = match && match[2];
+      if (region === 'us-gov') {
+        region = 'us-gov-west-1';
+      } else if (region === 's3' || region === 's3-accelerate') {
+        region = 'us-east-1';
+        service = 's3';
+      } else if (service === 'iot') {
+        if (hostname.startsWith('iot.')) {
+          service = 'execute-api';
+        } else if (hostname.startsWith('data.jobs.iot.')) {
+          service = 'iot-jobs-data';
+        } else {
+          service = pathname === '/mqtt' ? 'iotdevicegateway' : 'iotdata';
+        }
+      } else if (service === 'autoscaling') {
+        const targetPrefix = (headers.get('X-Amz-Target') || '').split('.')[0];
+        if (targetPrefix === 'AnyScaleFrontendService') {
+          service = 'application-autoscaling';
+        } else if (targetPrefix === 'AnyScaleScalingPlannerFrontendService') {
+          service = 'autoscaling-plans';
+        }
+      } else if (region == null && service.startsWith('s3-')) {
+        region = service.slice(3).replace(/^fips-|^external-1/, '');
+        service = 's3';
+      } else if (service.endsWith('-fips')) {
+        service = service.slice(0, -5);
+      } else if (region && /-\d$/.test(service) && !/-\d$/.test(region)) {
+    [service, region] = [region, service];
+      }
+      return [HOST_SERVICES[service] || service, region || '']
+    }
+
+    const LINUX_DISTRO_TOKENS = [
+        'ubuntu',
+        'debian',
+        'opensuse',
+        'suse',
+        'gentoo',
+        'arch linux',
+        'arch',
+        'fedora',
+        'centos',
+        'red hat',
+        'rhel',
+        'rocky linux',
+        'rocky',
+        'almalinux',
+        'alma',
+        'amazon linux',
+        'amazonlinux',
+        'amzn',
+        'manjaro',
+        'linux mint',
+        'mint',
+        'pop!_os',
+        'pop_os',
+        'kali',
+        'alpine',
+        'nixos',
+        'linux',
+    ];
+    function escapeRegExp(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    const LINUX_DISTRO_TOKEN_SOURCE = [...LINUX_DISTRO_TOKENS]
+        .sort((a, b) => b.length - a.length)
+        .map((token) => escapeRegExp(token))
+        .join('|');
+    const LINUX_DISTRO_TOKEN_REGEX = new RegExp(`\\b(${LINUX_DISTRO_TOKEN_SOURCE})\\b`, 'i');
+    const LINUX_DISTRO_VERSION_REGEX = new RegExp(`\\b(?:${LINUX_DISTRO_TOKEN_SOURCE})[\\s\\/_-]*([\\d\\.]+)`, 'i');
+    const LINUX_DISTRO_NAME_MAP = {
+        ubuntu: 'Ubuntu',
+        debian: 'Debian',
+        opensuse: 'openSUSE',
+        suse: 'SUSE',
+        gentoo: 'Gentoo',
+        arch: 'Arch Linux',
+        'arch linux': 'Arch Linux',
+        fedora: 'Fedora',
+        centos: 'CentOS',
+        'red hat': 'Red Hat',
+        rhel: 'Red Hat',
+        rocky: 'Rocky Linux',
+        'rocky linux': 'Rocky Linux',
+        alma: 'AlmaLinux',
+        almalinux: 'AlmaLinux',
+        'amazon linux': 'Amazon Linux',
+        amazonlinux: 'Amazon Linux',
+        amzn: 'Amazon Linux',
+        manjaro: 'Manjaro',
+        'linux mint': 'Linux Mint',
+        mint: 'Linux Mint',
+        'pop!_os': 'Pop!_OS',
+        pop_os: 'Pop!_OS',
+        kali: 'Kali Linux',
+        alpine: 'Alpine Linux',
+        nixos: 'NixOS',
+        linux: 'Linux',
+    };
+    function resolveLinuxDistroName(userAgent) {
+        const token = (userAgent.match(LINUX_DISTRO_TOKEN_REGEX) || [])[1];
+        if (!token) {
+            return undefined;
+        }
+        return LINUX_DISTRO_NAME_MAP[token.toLowerCase()];
+    }
+    function extractVersion(userAgent, versionRegex) {
+        if (!versionRegex) {
+            return undefined;
+        }
+        const version = (userAgent.match(versionRegex) || [])[1];
+        if (!version) {
+            return undefined;
+        }
+        return version.replace(/_/g, '.');
+    }
+    function parseOS(userAgent) {
+        if (!userAgent) {
+            return {};
+        }
+        const normalizedAgent = userAgent.toLowerCase();
+        const osMatchers = [
+            {
+                name: 'Windows Phone',
+                regex: /windows phone|windows mobile/i,
+                versionRegex: /windows (?:phone(?: os)?|mobile)[\s\/]*([\d\.]+)/i,
+            },
+            {
+                name: 'Windows',
+                regex: /windows nt|windows\s\d+/i,
+                versionRegex: /windows nt[\s\/]*([\d\.]+)/i,
+            },
+            {
+                name: 'iOS',
+                regex: /iphone|ipad|ipod|cpu (?:iphone )?os /i,
+                versionRegex: /os\s([\d_\.]+)/i,
+            },
+            {
+                name: 'Android',
+                regex: /android/i,
+                versionRegex: /android[\s\/]*([\d\.]+)/i,
+            },
+            {
+                name: 'ChromeOS',
+                regex: /\bcros\b/i,
+                versionRegex: /\bcros\b[^\)]*?([\d]+(?:\.[\d]+)+)/i,
+            },
+            {
+                name: 'MacOS',
+                regex: /mac os x|macos|macintosh|macintel|darwin/i,
+                versionRegex: /(?:mac os x|os x|macos)[\s\/]*([\d_\.]+)/i,
+            },
+            {
+                name: 'Linux',
+                regex: LINUX_DISTRO_TOKEN_REGEX,
+                versionRegex: LINUX_DISTRO_VERSION_REGEX,
+            },
+        ];
+        const matched = osMatchers.find((entry) => entry.regex.test(normalizedAgent));
+        if (!matched) {
+            return {};
+        }
+        const version = extractVersion(normalizedAgent, matched.versionRegex);
+        const name = matched.name === 'Linux'
+            ? resolveLinuxDistroName(normalizedAgent) || 'Linux'
+            : matched.name;
+        return {
+            name,
+            version,
+        };
+    }
+
+    function getNavigatorSafe() {
+        if (typeof window === 'undefined' || !window.navigator) {
+            return undefined;
+        }
+        return window.navigator;
+    }
+    function getLanguageInfo(nav) {
+        if (!nav) {
+            return '';
+        }
+        const lang = nav.language ||
+            nav.browserLanguage ||
+            (Array.isArray(nav.languages) && nav.languages.length > 0
+                ? nav.languages[0]
+                : 'en_US') ||
+            '';
+        return String(lang).toLowerCase().replace('-', '_');
+    }
+    function getBrowserTimezone() {
+        const tzMatch = /\(([A-Za-z\s].*)\)/.exec(new Date().toString());
+        return tzMatch ? tzMatch[1] || '' : '';
+    }
+    function parseBrowserType(userAgent) {
+        const operaMatch = /.+(Opera[\s[A-Z]*|OPR[\sA-Z]*)\/([0-9\.]+).*/i.exec(userAgent);
+        if (operaMatch) {
+            return {
+                type: operaMatch[1],
+                version: operaMatch[2],
+            };
+        }
+        const edgeOrTridentMatch = /.+(Trident|Edge)\/([0-9\.]+).*/i.exec(userAgent);
+        if (edgeOrTridentMatch) {
+            return {
+                type: edgeOrTridentMatch[1],
+                version: edgeOrTridentMatch[2],
+            };
+        }
+        const headlessMatch = /(headlesschrome)(?:\/([\w\.]+)| )/i.exec(userAgent);
+        if (headlessMatch) {
+            return {
+                type: headlessMatch[1],
+                version: headlessMatch[2],
+            };
+        }
+        const browserMatch = /.+(Chrome|Firefox|FxiOS)\/([0-9\.]+).*/i.exec(userAgent);
+        if (browserMatch) {
+            return {
+                type: browserMatch[1],
+                version: browserMatch[2],
+            };
+        }
+        const safariMatch = /.+(Safari)\/([0-9\.]+).*/i.exec(userAgent);
+        if (safariMatch) {
+            return {
+                type: safariMatch[1],
+                version: safariMatch[2],
+            };
+        }
+        const webkitMatch = /.+(AppleWebKit)\/([0-9\.]+).*/i.exec(userAgent);
+        if (webkitMatch) {
+            return {
+                type: webkitMatch[1],
+                version: webkitMatch[2],
+            };
+        }
+        const anyMatch = /.*([A-Z]+)\/([0-9\.]+).*/i.exec(userAgent);
+        const fallback = anyMatch || ['', 'NA', '0.0.0'];
+        return {
+            type: fallback[1],
+            version: fallback[2],
+        };
+    }
+    function getBrowserClientInfo() {
+        const nav = getNavigatorSafe();
+        if (!nav) {
+            return {};
+        }
+        const userAgent = nav.userAgent || '';
+        const browser = parseBrowserType(userAgent);
+        const isBrave = (nav.brave && nav.brave.isBrave) || false;
+        const type = isBrave ? 'Brave' : browser.type;
+        const os = parseOS(userAgent);
+        const vendorToken = (nav.vendor || '').split(' ').filter(Boolean)[0];
+        const make = type === 'Brave' ? type : vendorToken || nav.product || '';
+        return {
+            language: getLanguageInfo(nav),
+            make,
+            model: type,
+            version: browser.version,
+            name: [type, browser.version].filter(Boolean).join('/'),
+            timezone: getBrowserTimezone(),
+            platform: nav.platform,
+            os,
+        };
+    }
+
+    const PINPOINT_ENDPOINT_KEY = 'TELEMETRY_PINPOINT_ENDPOINT_ID';
+    const LOG_PREFIX = '[telemetry-amazon]';
+    function isDebugEnabled() {
+        var _a;
+        const processEnv = typeof globalThis !== 'undefined'
+            ? (_a = globalThis.process) === null || _a === void 0 ? void 0 : _a.env
+            : undefined;
+        return ((processEnv === null || processEnv === void 0 ? void 0 : processEnv.TELEMETRY_AMAZON_DEBUG) === 'true' ||
+            (processEnv === null || processEnv === void 0 ? void 0 : processEnv.NODE_ENV) === 'development');
+    }
+    function debugLog(message, details) {
+        if (!isDebugEnabled() || typeof console === 'undefined') {
+            return;
+        }
+        if (details && typeof console.debug === 'function') {
+            console.debug(`${LOG_PREFIX} ${message}`, details);
+            return;
+        }
+        if (typeof console.debug === 'function') {
+            console.debug(`${LOG_PREFIX} ${message}`);
+        }
+    }
+    function warnLog(message, details) {
+        if (typeof console === 'undefined' || typeof console.warn !== 'function') {
+            return;
+        }
+        if (details) {
+            console.warn(`${LOG_PREFIX} ${message}`, details);
+            return;
+        }
+        console.warn(`${LOG_PREFIX} ${message}`);
+    }
+    function getEndpointId() {
+        const cached = storage.get(PINPOINT_ENDPOINT_KEY);
+        if (cached && typeof cached === 'object' && cached.endpointId) {
+            return cached.endpointId;
+        }
+        if (typeof cached === 'string') {
+            return cached;
+        }
+        const generated = `telemetry-${Date.now()}-${Math.random()
+        .toString(16)
+        .slice(2)}`;
+        storage.set(PINPOINT_ENDPOINT_KEY, { endpointId: generated });
+        return generated;
+    }
+
+    const ESRI_SIGNING_SERVICE = 'execute-api';
+    const ESRI_SIGNING_REGION = 'us-east-1';
+    const ESRI_ENDPOINT_URL = (appId) => `https://tedev.arcgis.com/v1/apps/${appId}/events`;
+    const SESSION_START_EVENT = '_session.start';
+    const SESSION_STOP_EVENT = '_session.stop';
+    const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
+    const DEFAULT_DEBOUNCE_MS = 5000;
+    /** Converts a string to a number, guarded against invalid values */
+    function getNumber(value, fallback = 0) {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : fallback;
+    }
+    /** Splits an EsriBatchEventPayload into attributes and metrics */
+    function splitEventData(payload) {
+        const attributes = {};
+        const metrics = {};
+        const excludedKeys = new Set([
+            'name',
+            'appTitle',
+            'appVersion',
+            'clientSdkVersion',
+            'deviceMake',
+            'deviceModel',
+            'city',
+            'country',
+            'lat',
+            'lon',
+        ]);
+        Object.entries(payload || {}).forEach(([key, value]) => {
+            if (excludedKeys.has(key) || value === undefined || value === null) {
+                return;
+            }
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                metrics[key] = value;
+                return;
+            }
+            if (typeof value === 'string' || typeof value === 'boolean') {
+                attributes[key] = String(value);
+                return;
+            }
+            if (Array.isArray(value) || typeof value === 'object') {
+                attributes[key] = JSON.stringify(value);
+            }
+        });
+        return {
+            attributes,
+            metrics,
+        };
+    }
+    /** Constructs an event payload in the shape expected by the endpoint.  */
+    function buildBatchEventPayload({ queuedEvents, trackerName, appName, appVersion, }) {
+        var _a, _b, _c, _d, _e, _f;
+        const endpointEvent = queuedEvents[queuedEvents.length - 1] ||
+            {
+                payload: {},
+                browserInfo: {},
+            };
+        const payload = endpointEvent.payload || {};
+        const browserInfo = endpointEvent.browserInfo || {};
+        const endpointId = getEndpointId();
+        const location = {};
+        if (payload === null || payload === void 0 ? void 0 : payload.city) {
+            location.City = payload.city;
+        }
+        if (payload === null || payload === void 0 ? void 0 : payload.country) {
+            location.Country = payload.country;
+        }
+        if ((payload === null || payload === void 0 ? void 0 : payload.lat) !== undefined && (payload === null || payload === void 0 ? void 0 : payload.lat) !== null) {
+            location.Lat = getNumber(payload.lat);
+        }
+        if ((payload === null || payload === void 0 ? void 0 : payload.lon) !== undefined && (payload === null || payload === void 0 ? void 0 : payload.lon) !== null) {
+            location.Lon = getNumber(payload.lon);
+        }
+        return {
+            BatchEvent: {
+                Endpoint: {
+                    Id: endpointId,
+                    Device: Object.assign({ Locale: (browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.language) || '', Make: (payload === null || payload === void 0 ? void 0 : payload.deviceMake) || (browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.make) || '', Model: (payload === null || payload === void 0 ? void 0 : payload.deviceModel) || (browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.model) || '', ModelVersion: (browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.version) || '', Platform: ((_a = browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.os) === null || _a === void 0 ? void 0 : _a.name) || (browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.platform) || '' }, (((_b = browserInfo === null || browserInfo === void 0 ? void 0 : browserInfo.os) === null || _b === void 0 ? void 0 : _b.version)
+                        ? { PlatformVersion: browserInfo.os.version }
+                        : {})),
+                    Location: location,
+                    Application: {
+                        AppTitle: (_d = (_c = payload === null || payload === void 0 ? void 0 : payload.appTitle) !== null && _c !== void 0 ? _c : appName) !== null && _d !== void 0 ? _d : trackerName,
+                        AppVersion: (_e = payload === null || payload === void 0 ? void 0 : payload.appVersion) !== null && _e !== void 0 ? _e : appVersion,
+                        ClientSdkVersion: (_f = payload === null || payload === void 0 ? void 0 : payload.clientSdkVersion) !== null && _f !== void 0 ? _f : trackerName,
+                    },
+                },
+                Events: queuedEvents.map((queuedEvent) => {
+                    const timestamp = queuedEvent.timestamp;
+                    const { attributes, metrics } = splitEventData(queuedEvent.payload);
+                    const sessionContext = queuedEvent.session ||
+                        {
+                            id: `${queuedEvent.unixMs}-${Math.random().toString(16).slice(2)}`,
+                            startTimestamp: timestamp,
+                            startUnixMs: queuedEvent.unixMs,
+                        };
+                    const isStopEvent = queuedEvent.eventName === SESSION_STOP_EVENT;
+                    return {
+                        EventType: queuedEvent.eventName,
+                        Timestamp: timestamp,
+                        Session: {
+                            Id: sessionContext.id,
+                            StartTimestamp: sessionContext.startTimestamp,
+                            EndTimestamp: timestamp,
+                            Duration: isStopEvent
+                                ? Math.max(0, queuedEvent.unixMs - sessionContext.startUnixMs)
+                                : 0,
+                        },
+                        Attributes: attributes,
+                        Metrics: metrics,
+                    };
+                }),
+            },
+        };
+    }
+    function createEsriPlugin({ trackerName, appName, appId, appVersion, userPoolID, fips, debounceMs = DEFAULT_DEBOUNCE_MS, }) {
+        const url = ESRI_ENDPOINT_URL(appId);
+        let isDisabled = false;
+        let hasWarned = false;
+        let hasSessionStarted = false;
+        let sessionStopSent = false;
+        let activeSession;
+        let idleTimerId;
+        let debounceTimerId;
+        let lifecycleListenersAttached = false;
+        const removeLifecycleListeners = [];
+        let pendingEvents = [];
+        const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
+        const warnOnce = (message, details) => {
+            if (hasWarned) {
+                return;
+            }
+            hasWarned = true;
+            warnLog(message, details);
+        };
+        debugLog('createEsriPlugin initialized', {
+            trackerName,
+            hasUrl: Boolean(url),
+        });
+        if (!url) {
+            isDisabled = true;
+            warnOnce('Esri telemetry disabled due to missing internal endpoint URL', {
+                trackerName,
+            });
+        }
+        if (!userPoolID) {
+            isDisabled = true;
+            warnOnce('Esri telemetry disabled due to missing userPoolID', {
+                trackerName,
+            });
+        }
+        if (typeof fetch !== 'function') {
+            isDisabled = true;
+            warnOnce('Esri telemetry disabled because fetch is unavailable', {
+                trackerName,
+            });
+        }
+        const clearIdleTimer = () => {
+            if (!idleTimerId) {
+                return;
+            }
+            clearTimeout(idleTimerId);
+            idleTimerId = undefined;
+        };
+        const clearDebounceTimer = () => {
+            if (!debounceTimerId) {
+                return;
+            }
+            clearTimeout(debounceTimerId);
+            debounceTimerId = undefined;
+        };
+        const clearPendingEvents = () => {
+            pendingEvents = [];
+        };
+        const enqueueEvent = (event) => {
+            pendingEvents.push(event);
+        };
+        const dequeuePendingEvents = () => {
+            if (pendingEvents.length === 0) {
+                return [];
+            }
+            const queuedEvents = pendingEvents;
+            pendingEvents = [];
+            return queuedEvents;
+        };
+        const sendQueuedEvents = (queuedEvents) => {
+            var _a;
+            if (queuedEvents.length === 0) {
+                return;
+            }
+            if (isDisabled || !url || !userPoolID) {
+                debugLog('Skipping esri track call', {
+                    eventName: (_a = queuedEvents[queuedEvents.length - 1]) === null || _a === void 0 ? void 0 : _a.eventName,
+                    reason: 'plugin-disabled',
+                });
+                return;
+            }
+            debugLog('Sending esri endpoint batch event', {
+                trackerName,
+                url,
+                eventCount: queuedEvents.length,
+            });
+            void (async () => {
+                var _a;
+                try {
+                    const credentials = await getCredentials(userPoolID, { fips });
+                    const accessKeyId = (credentials === null || credentials === void 0 ? void 0 : credentials.AccessKeyId) || (credentials === null || credentials === void 0 ? void 0 : credentials.accessKeyId);
+                    const secretAccessKey = (credentials === null || credentials === void 0 ? void 0 : credentials.SecretKey) || (credentials === null || credentials === void 0 ? void 0 : credentials.secretAccessKey);
+                    const sessionToken = (credentials === null || credentials === void 0 ? void 0 : credentials.SessionToken) || (credentials === null || credentials === void 0 ? void 0 : credentials.sessionToken);
+                    if (!accessKeyId || !secretAccessKey) {
+                        throw new Error('Signed endpoint credentials are missing required key fields.');
+                    }
+                    const client = new AwsClient({
+                        accessKeyId,
+                        secretAccessKey,
+                        sessionToken,
+                        service: ESRI_SIGNING_SERVICE,
+                        region: ESRI_SIGNING_REGION,
+                    });
+                    await client.fetch(url, {
+                        method: 'POST',
+                        headers: {
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify(buildBatchEventPayload({
+                            queuedEvents,
+                            trackerName,
+                            appName,
+                            appVersion,
+                        })),
+                    });
+                    debugLog('Endpoint event sent', {
+                        trackerName,
+                        eventCount: queuedEvents.length,
+                    });
+                }
+                catch (error) {
+                    isDisabled = true;
+                    clearIdleTimer();
+                    clearDebounceTimer();
+                    clearPendingEvents();
+                    removeAllLifecycleListeners();
+                    warnOnce('Esri telemetry disabled after endpoint track failure', {
+                        eventName: (_a = queuedEvents[queuedEvents.length - 1]) === null || _a === void 0 ? void 0 : _a.eventName,
+                        trackerName,
+                        message: (error === null || error === void 0 ? void 0 : error.message) || String(error),
+                    });
+                }
+            })();
+        };
+        const flushPendingEvents = (eventToAppend) => {
+            clearDebounceTimer();
+            const queuedEvents = dequeuePendingEvents();
+            if (eventToAppend) {
+                queuedEvents.push(eventToAppend);
+            }
+            sendQueuedEvents(queuedEvents);
+        };
+        const scheduleDebounceFlush = () => {
+            clearDebounceTimer();
+            debounceTimerId = setTimeout(() => {
+                flushPendingEvents();
+            }, debounceMs);
+        };
+        const removeAllLifecycleListeners = () => {
+            removeLifecycleListeners.splice(0).forEach((removeListener) => {
+                removeListener();
+            });
+            lifecycleListenersAttached = false;
+        };
+        const createSession = () => {
+            const now = Date.now();
+            return {
+                id: `${now}-${Math.random().toString(16).slice(2)}`,
+                startTimestamp: new Date(now).toISOString(),
+                startUnixMs: now,
+            };
+        };
+        const sendEvent = (eventName, payload, sessionOverride, options, forceImmediate = false) => {
+            if (isDisabled || !url || !userPoolID) {
+                debugLog('Skipping esri track call', {
+                    eventName,
+                    reason: 'plugin-disabled',
+                });
+                return false;
+            }
+            debugLog('Queueing esri endpoint event', {
+                eventName,
+                trackerName,
+                immediate: Boolean((options === null || options === void 0 ? void 0 : options.immediate) || forceImmediate),
+            });
+            const queuedEvent = {
+                eventName,
+                payload: payload,
+                session: sessionOverride || activeSession,
+                browserInfo: getBrowserClientInfo(),
+                timestamp: new Date().toISOString(),
+                unixMs: Date.now(),
+            };
+            if ((options === null || options === void 0 ? void 0 : options.immediate) || forceImmediate) {
+                flushPendingEvents(queuedEvent);
+            }
+            else {
+                enqueueEvent(queuedEvent);
+                scheduleDebounceFlush();
+            }
+            return true;
+        };
+        const sendSessionLifecycleEvent = (eventName, reason, sessionOverride) => {
+            return sendEvent(eventName, {
+                reason,
+            }, sessionOverride, undefined, true);
+        };
+        const stopSession = (reason) => {
+            if (!hasSessionStarted || sessionStopSent) {
+                return false;
+            }
+            const sessionToStop = activeSession;
+            const didStop = sendSessionLifecycleEvent(SESSION_STOP_EVENT, reason, sessionToStop);
+            if (didStop) {
+                sessionStopSent = true;
+                hasSessionStarted = false;
+                clearIdleTimer();
+                activeSession = undefined;
+            }
+            return didStop;
+        };
+        const startSession = (reason) => {
+            if (hasSessionStarted) {
+                return false;
+            }
+            activeSession = activeSession || createSession();
+            const sessionToStart = activeSession;
+            const didStart = sendSessionLifecycleEvent(SESSION_START_EVENT, reason, sessionToStart);
+            if (didStart) {
+                hasSessionStarted = true;
+                sessionStopSent = false;
+            }
+            else {
+                activeSession = undefined;
+            }
+            return didStart;
+        };
+        const resetIdleTimer = () => {
+            if (!isBrowser || isDisabled || !hasSessionStarted) {
+                return;
+            }
+            clearIdleTimer();
+            idleTimerId = setTimeout(() => {
+                stopSession('idle');
+            }, DEFAULT_IDLE_TIMEOUT_MS);
+        };
+        const handleActivity = () => {
+            if (isDisabled) {
+                return;
+            }
+            if (!hasSessionStarted) {
+                startSession('wakeup');
+            }
+            resetIdleTimer();
+        };
+        const addLifecycleListener = (target, eventName, listener) => {
+            target.addEventListener(eventName, listener);
+            removeLifecycleListeners.push(() => {
+                target.removeEventListener(eventName, listener);
+            });
+        };
+        const attachLifecycleListeners = () => {
+            if (!isBrowser || lifecycleListenersAttached || isDisabled) {
+                return;
+            }
+            const activityEvents = ['pointerdown', 'keydown', 'scroll', 'focus'];
+            activityEvents.forEach((eventName) => {
+                addLifecycleListener(window, eventName, handleActivity);
+            });
+            addLifecycleListener(window, 'beforeunload', () => {
+                stopSession('beforeunload');
+            });
+            lifecycleListenersAttached = true;
+        };
+        return {
+            track: (eventName, payload, options) => {
+                attachLifecycleListeners();
+                const isSessionStopEvent = eventName === SESSION_STOP_EVENT;
+                if (!hasSessionStarted &&
+                    eventName !== SESSION_START_EVENT &&
+                    !isSessionStopEvent) {
+                    startSession('init');
+                }
+                if (eventName === SESSION_START_EVENT) {
+                    activeSession = activeSession || createSession();
+                    hasSessionStarted = true;
+                    sessionStopSent = false;
+                }
+                if (isSessionStopEvent) {
+                    sessionStopSent = true;
+                    hasSessionStarted = false;
+                    clearIdleTimer();
+                }
+                if (hasSessionStarted && !activeSession && !isSessionStopEvent) {
+                    activeSession = createSession();
+                }
+                if (hasSessionStarted && !isSessionStopEvent) {
+                    resetIdleTimer();
+                }
+                const sessionForEvent = activeSession;
+                const didSend = sendEvent(eventName, payload, sessionForEvent, options, eventName === SESSION_START_EVENT || eventName === SESSION_STOP_EVENT);
+                if (isSessionStopEvent && didSend) {
+                    activeSession = undefined;
+                }
+                return didSend;
+            },
+        };
+    }
+
+    // October 31, 2026
+    const PINPOINT_RETIREMENT_CUTOFF_UTC_MS = Date.parse('2026-10-31T00:00:00.000Z');
     /**
      * Amazon Telemetry
-     * Supports Amazon Pinpoint
+     * Supports Pinpoint and Esri endpoint modes
      */
     class Amazon {
         constructor(options) {
             this.name = 'amazon';
+            this.previousPage = {};
             this.isInitialized = false;
-            const { app = {}, fips, userPoolID } = options;
-            this.analytics = analyticsLib({
-                app: app.name,
-                version: app.version,
-                plugins: [
-                    awsPinpointPlugin__default["default"]({
-                        fips,
-                        pinpointAppId: app.id,
-                        getCredentials: () => {
-                            return getCredentials(userPoolID, { fips });
-                        },
-                    }),
-                ],
-            });
+            this.appConfig = {};
+            this.isPinpointRetired = (nowMs = Date.now()) => nowMs >= PINPOINT_RETIREMENT_CUTOFF_UTC_MS;
+            // default to `esri` mode if not specified
+            const { app = {}, fips, userPoolID, mode = 'esri' } = options;
             Object.assign(this, options);
+            this.appConfig = app;
+            this.userPoolIDConfig = userPoolID;
+            this.fipsConfig = fips;
+            /** @deprecated Pinpoint is retiring on October 31, 2026. After this point all traffic will be routed to the in-house endpoint */
+            if (mode === 'pinpoint' && !this.isPinpointRetired()) {
+                this.mode = 'pinpoint';
+                this.analytics = analyticsLib({
+                    app: app.name,
+                    version: app.version,
+                    plugins: [
+                        awsPinpointPlugin__default["default"]({
+                            fips,
+                            pinpointAppId: app.id,
+                            getCredentials: () => getCredentials(userPoolID, { fips }),
+                        }),
+                    ],
+                });
+                return;
+            }
+            this.mode = 'esri';
+            this.analytics = createEsriPlugin({
+                trackerName: this.name,
+                appName: this.appConfig.name,
+                appVersion: this.appConfig.version,
+                appId: this.appConfig.id,
+                userPoolID: this.userPoolIDConfig,
+                fips: this.fipsConfig,
+            });
         }
         init() {
             // if already initialized, return
@@ -1429,16 +2539,18 @@
             });
             const { pageUrl, pageName } = telemetryPayload;
             this.previousPage = { pageUrl, pageName };
-            this.analytics.track('pageView', telemetryPayload);
+            const result = this.analytics.track('pageView', telemetryPayload);
+            return typeof result === 'boolean' ? result : true;
         }
-        logEvent(event = {}) {
+        logEvent(event = {}, trackOptions) {
             const telemetryPayload = createEventLog({
                 event,
                 dimensionLookup: this.dimensions,
                 metricLookup: this.metrics,
             });
             const { name } = telemetryPayload;
-            this.analytics.track(name, telemetryPayload);
+            const result = this.analytics.track(name, telemetryPayload, trackOptions);
+            return typeof result === 'boolean' ? result : true;
         }
     }