diff --git a/Documentation.md b/Documentation.md index e7b720b..3320d06 100644 --- a/Documentation.md +++ b/Documentation.md @@ -1488,6 +1488,50 @@ Add a new outbound third-party connection to this contact and connect it to the Optional success and failure callbacks can be provided to determine if the operation was successful. +**This API is on deprecation path, please use either `contact.addParticipant()` or `contact.transfer()`** + +### `contact.addParticipant()` + +```js +// endpoint: Endpoint Object +contact.addParticipant(endpoint, { + success: function () { + /* ... */ + }, + failure: function (err) { + /* ... */ + }, +}); +``` + +Add a new participant to either a Voice or Chat contact, and connect it to the specified `endpoint`. + +Optional success and failure callbacks can be provided to determine if the operation was successfully invoked. + +This API is **only** supported in **Voice** and **Chat**. Will return an error if used on an unsupported contact type. + +### `contact.transfer()` + +```js +// endpoint: Endpoint Object +contact.transfer(endpoint, { + success: function () { + /* ... */ + }, + failure: function (err) { + /* ... */ + }, +}); +``` + +Transfer the contact to the specified `endpoint`. + +Only supports the following endpoint types: `EndpointType.QUEUE` and `EndpointType.AGENT`. + +Optional success and failure callbacks can be provided to determine if the operation was successfully invoked. + +This API is **only** supported in **Chat**, **Task**, and **Email**. Will return an error if used on an unsupported contact type. + ### `contact.toggleActiveConnections()` ```js contact.toggleActiveConnections({ @@ -2094,6 +2138,46 @@ var monitorStatus = conn.getMonitorStatus(); Returns the current monitoring state of this connection. This value can be one of MonitoringMode enum values if the agent is supervisor, otherwise the monitorStatus will be undefined for the agent. + +### `chatConnection.getAuthenticationDetails()` +Get authentication details for customer in chat. +```js + +const customerConnection = contact.getConnections().find(conn => + conn.getType() === connect.ConnectionType.INBOUND); +const customerAuthDetails = customerConnection.getAuthenticationDetails(); +``` + + The authentication details response object includes: + +``` +{ + "IdentityProvider": "http://my-domain.auth0.com", + // The identity provider that issued the authentication + "ClientId": "xxxxxxxxxxxxexample", + // The user pool app client that authenticated your user. + "Status": "AUTHENTICATED" | "FAILED" | "TIMEOUT", + // Enum which represents whether the customer is authenticated or not + "AssociatedCustomerId": "3b3fe046ed68479f9d425b5f1a7acbfe", + // Metadata for the customer profile associated with the contact + "AuthenticationMethod": "CONNECT" | "CUSTOM", + // Connect managed auth vs customer managed auth. +} +``` + +### `chatConnection.isAuthenticated()` + +Determine if customer in chat is authenticated. + +```js +const customerConnection = contact.getConnections().find(conn => + conn.getType() === connect.ConnectionType.INBOUND); +if (customerConnection.isAuthenticated()) { + /* ... */ +} +``` + + ## TaskConnection API The TaskConnection API provides action methods (no event subscriptions) which can be called to manipulate the state of a particular task connection within a contact. Like contacts, connections come and go. It is good practice not @@ -2355,13 +2439,41 @@ eventBus.subscribe(connect.EventType.TERMINATED, () => { }); ``` -If you are using a custom UI, you can log out the agent by visiting the logout endpoint (`/connect/logout`). In this case, `EventType.TERMINATED` event won't be triggered. If you want the code above to work, you can manually trigger the `EventType.TERMINATE` event after logging out. When the event is triggered, `connect.core.terminate()` is internally called to clean up the Streams and the `EventType.TERMINATED` event will be triggered. +If you are using a custom UI, you can log out the agent by visiting the logout endpoint (`/logout`). Also it's recommended to set agent offline before logging out to prevent contacts from being routed to the agent. + ```js -fetch("https:///connect/logout", { credentials: 'include', mode: 'no-cors'}) - .then(() => { - const eventBus = connect.core.getEventBus(); - eventBus.trigger(connect.EventType.TERMINATE); +function handleLogoutButtonClick() { + const agent = new connect.Agent(); + if (agent.getState().type === connect.AgentStatusType.OFFLINE) { + logout(); + } else { + setAgentOffline() + .then(logout) + .catch(console.error); + } +} + +function setAgentOffline() { + return new Promise((resolve, reject) => { + const agent = new connect.Agent(); + const offlineState = agent.getAgentStates().find( + (state) => state.type === connect.AgentStateType.OFFLINE, + ); + agent.setState(offlineState, { + success: resolve, + failure: reject, + }, { enqueueNextState: true }); }); +} + +function logout() { + const logoutEndpoint = "https:///logout"; + fetch(logoutEndpoint, { credentials: 'include', mode: 'no-cors'}) + .then(() => { + // Notify all CCPs to terminate + connect.core.getUpstream().sendUpstream(connect.EventType.TERMINATE); + }); +} ``` In addition, it is recommended to remove the auth token cookies (`lily-auth-*`) after logging out, otherwise you’ll see AuthFail errors. ([Browser API Reference](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies/remove)). diff --git a/README.md b/README.md index 506708e..3d77aba 100644 --- a/README.md +++ b/README.md @@ -19,48 +19,50 @@ In version 1.x, we also support `make` for legacy builds. This option was remove # Important Announcements -1. November 2024 - Major changes: +1. December 2024 - Major changes: + * Introducing Multiparty Chat, allowing up to 4 additional agents to join an ongoing chat conversation, making it easier to collaborate and resolve customer issues quickly. +2. November 2024 - Major changes: * Introducing Email * Storage access settings from `initCCP` are now deprecated after Google is no longer deprecating 3rd party cookies by default. * Global resiliency involving `connect-streams-dr.js` is now deprecated. Please reference [Documentation-GR.md](Documentation-GR.md) for the new set of APIs. -2. July 2024 - The issue with muting while a Voice contact is on hold has been resolved. Agents can use the mute button while a contact is placed on hold. The following APIs will be available when the contact is on hold: +3. July 2024 - The issue with muting while a Voice contact is on hold has been resolved. Agents can use the mute button while a contact is placed on hold. The following APIs will be available when the contact is on hold: * `voiceConnection.muteParticipant()` * `voiceConnection.unmuteParticipant()` * `agent.mute()` * `agent.unmute()` -3. February 2024 - In response to a Google Chrome feature launched on 7/13/2023 called [Storage Partitioning](https://developers.google.com/privacy-sandbox/3pcd/storage-partitioning), we made a short term fix on 2/10/2024 to adjust our mute functionality and synchronize the mute state across all CCPs. However, due to current limitations, this change required us to disable muting while being on hold. As a workaround, agents should mute themselves on the call before going on hold. We are planning to address this issue by August 2024 and revert back to original mute behavior. +4. February 2024 - In response to a Google Chrome feature launched on 7/13/2023 called [Storage Partitioning](https://developers.google.com/privacy-sandbox/3pcd/storage-partitioning), we made a short term fix on 2/10/2024 to adjust our mute functionality and synchronize the mute state across all CCPs. However, due to current limitations, this change required us to disable muting while being on hold. As a workaround, agents should mute themselves on the call before going on hold. We are planning to address this issue by August 2024 and revert back to original mute behavior. * At the moment, the following APIs will fail when the contact is on hold: * `voiceConnection.muteParticipant()` * `voiceConnection.unmuteParticipant()` * `agent.mute()` * `agent.unmute()` * As a workaround, you can mute the call prior to placing the call on hold. -4. December 2022 - In addition to the CCP, customers can now embed an application that provides guided experiences to your agents using the connect.agentApp. See the [updated documentation](https://github.com/amazon-connect/amazon-connect-streams/blob/master/Documentation.md#initialization-for-ccp-customer-profiles-amazon-q-connect-and-customviews) for details on usage. +5. December 2022 - In addition to the CCP, customers can now embed an application that provides guided experiences to your agents using the connect.agentApp. See the [updated documentation](https://github.com/amazon-connect/amazon-connect-streams/blob/master/Documentation.md#initialization-for-ccp-customer-profiles-amazon-q-connect-and-customviews) for details on usage. * ### Guided experiences for agents + With Amazon Connect you can now create guided step-by-step experiences that walk agents through tailored views that focus on what must be seen or done by the agent at a given moment during an interaction. You can design workflows for various types of customer interactions and present agents with different step-by-step guides based on context, such as call queue, customer information, and interactive voice response (IVR). This feature is available in the Connect agent workspace as well as an embeddable application that can be embedded into another website via the Streams API. For more information, visit the AWS website: https://aws.amazon.com/connect/agent-workspace/ -5. December 2022 - 2.4.2 +6. December 2022 - 2.4.2 * This patch fixes an issue in Streams’ Voice ID APIs that may have led to incorrect values being set against the generatedSpeakerID field in the VoiceIdResult segment of Connect Contact Trace Records (CTRs). This occurred in some scenarios where you call either enrollSpeakerInVoiceId(), evaluateSpeakerWithVoiceId(), or updateVoiceIdSpeakerId() in your custom CCP integration code. If you are using Voice ID and consuming Voice ID CTRs, or updating speaker ID in your agent workflow, please upgrade to this version. -6. December 2022 - 2.4.1 +7. December 2022 - 2.4.1 * This version brings in updates that will provide enhanced monitoring experience to agents and supervisors, allowing to silently monitor multiparty calls, and if needed to barge in the call and take over control, mute agents, or drop them from the call. New APIs introduced with this feature are `isSilentMonitor`, `isBarge`, `isSilentMonitorEnabled`, `isBargeEnabled`, `isUnderSupervision`, `updateMonitorParticipantState`, `getMonitorCapabilities`, `getMonitorStatus`, `isForcedMute`. -7. August 2022 - 2.3.0 +8. August 2022 - 2.3.0 * [Update on 12/13/2022] Please see 2.4.2 for final resolution of the Voice ID CTR fix. -8. Jan 2022 - 2.0.0 +9. Jan 2022 - 2.0.0 * Multiple calls to `initCCP` will no longer append multiple embedded CCPs to the window, and only the first call to `initCCP` will succeed. Please note that the use-case of initializing multiple CCPs with `initCCP` has never been supported by Streams, and this change has been added to prevent unpredictable behavior arising from such cases. * `agent.onContactPending` has been removed. Please use `contact.onPending` instead. `connect.onError` now triggers. Previously, this api did not work at all. Please be aware that, if you have application logic within this function, its behavior has changed. See its entry in documentation.md for more details. -9. September 2021 - 1.7.0 comes with changes needed to use Amazon Connect Voice ID, which launched on 9/27/2021. For customers who want to use Voice ID, please upgrade Streams to version 1.7.0 or later in the next 1 month, otherwise the Voice ID APIs will stop working by the end of October 2021. For more details on the Voice ID APIs, please look at [the Voice ID APIs section](Documentation.md#voice-id-apis). -10. July 2021 - We released a change to the CCP that lets agent set a next status such as Lunch or Offline while still on a contact, and indicate they don’t want to be routed new contacts while they finish up their remaining work. For more details on this feature, see the [Amazon Connect agent training guide](https://docs.aws.amazon.com/connect/latest/adminguide/set-next-status.html) and the feature's [release notes](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-release-notes.html#july21-release-notes). If your agents interact directly with Connect’s out-of-the-box CCPV2 UX, they will be able to access this feature by default. Otherwise, if your streamsJS application calls `agent.setState()` to switch agent status, you will need to update your code to use this feature: +10. September 2021 - 1.7.0 comes with changes needed to use Amazon Connect Voice ID, which launched on 9/27/2021. For customers who want to use Voice ID, please upgrade Streams to version 1.7.0 or later in the next 1 month, otherwise the Voice ID APIs will stop working by the end of October 2021. For more details on the Voice ID APIs, please look at [the Voice ID APIs section](Documentation.md#voice-id-apis). +11. July 2021 - We released a change to the CCP that lets agent set a next status such as Lunch or Offline while still on a contact, and indicate they don’t want to be routed new contacts while they finish up their remaining work. For more details on this feature, see the [Amazon Connect agent training guide](https://docs.aws.amazon.com/connect/latest/adminguide/set-next-status.html) and the feature's [release notes](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-release-notes.html#july21-release-notes). If your agents interact directly with Connect’s out-of-the-box CCPV2 UX, they will be able to access this feature by default. Otherwise, if your streamsJS application calls `agent.setState()` to switch agent status, you will need to update your code to use this feature: * **Agent.setState()** has been updated so you can pass an optional flag `enqueueNextState: true` to trigger the Next Status behavior. * A new **agent.onEnqueuedNextState()** listener lets you subscribe to events for when agents have selected/successfully enqueued their next status. * A new **agent.getNextState()** API returns a state object if the agent has successfully selected a next state, and null otherwise. * If you want to use the Next Status feature via `agent.setState()`, please also ensure that your code is using `contact.clear()` and not `contact.complete()` when clearing After Contact Work off a contact. -11. December 2020 — 1.6.0 brings with it the release of a new Agent App API. In addition to the CCP, customers can now embed additional applications using connect.agentApp, including Customer Profiles and Amazon Q Connect. See the [updated documentation](Documentation.md#initialization-for-ccp-customer-profiles-and-amazon-q-connect) for details on usage. We are also introducing a preview release for Amazon Connect Voice ID. +12. December 2020 — 1.6.0 brings with it the release of a new Agent App API. In addition to the CCP, customers can now embed additional applications using connect.agentApp, including Customer Profiles and Amazon Q Connect. See the [updated documentation](Documentation.md#initialization-for-ccp-customer-profiles-and-amazon-q-connect) for details on usage. We are also introducing a preview release for Amazon Connect Voice ID. * ### About Amazon Connect Customer Profiles + Amazon Connect Customer Profiles provides pre-built integrations so you can quickly combine customer information from multiple external applications, with contact history from Amazon Connect. This allows you to create a customer profile that has all the information agents need during customer interactions in a single place. * ### About Amazon Q in Connect + With Amazon Q Connect, agents can search and find content across multiple repositories, such as frequently asked questions (FAQs), wikis, articles, and step-by-step instructions for handling different customer issues. They can type questions or phrases in a search box (such as, "how long after purchase can handbags be exchanged?") without having to guess which keywords will work. * ### About Amazon Connect Voice ID (The feature is in preview release for Amazon Connect and is subject to change) + Amazon Connect Voice ID provides real-time caller authentication which makes voice interactions in contact centers more secure and efficient. Voice ID uses machine learning to verify the identity of genuine customers by analyzing a caller’s unique voice characteristics. This allows contact centers to use an additional security layer that doesn’t rely on the caller answering multiple security questions, and makes it easy to enroll and verify customers without changing the natural flow of their conversation. -12. July 2020 -- We recently changed the new, omnichannel, CCP's behavior when it encounters three voice-only agent states: `FailedConnectAgent`, `FailedConnectCustomer`, and `AfterCallWork`. +13. July 2020 -- We recently changed the new, omnichannel, CCP's behavior when it encounters three voice-only agent states: `FailedConnectAgent`, `FailedConnectCustomer`, and `AfterCallWork`. * `FailedConnectAgent` -- Previously, we required the agent to click the "Clear Contact" button to clear this state. When the agent clicked the "Clear Contact" button, the previous behavior took the agent back to the `Available` state without fail. Now the `FailedConnectAgent` state will be "auto-cleared", much like `FailedConnectCustomer` always has been. * `FailedConnectAgent` and `FailedConnectCustomer` -- We are now using the `contact.clear()` API to auto-clear these states. As a result, the agent will be returned to their previous visible agent state (e.g. `Available`). Previously, the agent had always been set to `Available` as a result of this "auto-clearing" behavior. Note that even custom CCPs will behave differently with this update for `FailedConnectAgent` and `FailedConnectCustomer`. * `AfterCallWork` -- As part of the new `contact.clear()` behavior, clicking "Clear Contact" while in `AfterCallWork` will return the agent to their previous visible agent state (e.g. `Available`, etc.). Note that custom CCPs that implement their own After Call Work behavior will not be affected by this change. diff --git a/cheat-sheet.md b/cheat-sheet.md index dc16751..67dc0a0 100644 --- a/cheat-sheet.md +++ b/cheat-sheet.md @@ -1,360 +1,355 @@ # Streams API - Cheat sheet -## Get agent config +## Get Agent Instance +You can obtain an agent instance using either the `connect.agent(callback)` API or the `new connect.Agent()` API. +- `connect.agent(callback)`: Can be called at any time after invoking `connect.core.initCCP()`. The callback will be triggered once the agent is initialized or immediately if already initialized. +- `new connect.Agent()`: Preferred when you want fewer callbacks. However, ensure the agent is initialized before calling this, as it will throw an error otherwise. +An agent is considered initialized after the first agent data is retrieved from the backend and `connect.agent()` is triggered. Logging out of Connect uninitializes the agent. ```js - connect.agent(function(agent) { - var config = agent.getConfiguration(); - console.log("here is your configuration: " + JSON.stringify(config)); - }); +// Using connect.agent(callback) +connect.agent((agent) => { + const state = agent.getState(); +}); ``` - -## Get agent states - ```js - connect.agent(function(agent) { - var states = agent.getAgentStates(); - console.log("here are your states: " + JSON.stringify(states)); - }); +// Using new connect.Agent() +// Make sure to use this approach only after agent is initialized. +const agent = new connect.Agent(); +const state = agent.getState(); ``` -## Change agent state - +## Get Agent State +Get the current state of the agent: ```js - connect.agent(function(agent) { - var targetState = agent.getAgentStates()[0]; - agent.setState(targetState, { - success: function () { - console.log("Set agent status via Streams") - }, - failure: function () { - console.log("Failed to set agent status via Streams") - } - }); - }); +const state = agent.getState(); +console.log("Agent's current state", state); ``` -## Change agent state to OFFLINE +## Get All Agent States +Get all possible agent states: ```js - connect.agent(function(agent) { - var offlineState = agent.getAgentStates().filter(function (state) { - return state.type === connect.AgentStateType.OFFLINE; })[0]; - agent.setState(offlineState, { - success: function () { - console.log("Set agent status to Offline via Streams") - }, - failure: function () { - console.log("Failed to set agent status to Offline via Streams") - } - }); - }); +const states = agent.getAgentStates(); +console.log("All agent states:", states); ``` -## Change agent state to AVAILABLE - +## Change Agent State to OFFLINE +Set the agent state to OFFLINE: ```js - connect.agent(function(agent) { - var avail = agent.getAgentStates().filter(function (state) { - return state.type === connect.AgentStateType.ROUTABLE; - })[0]; - agent.setState(avail, { - success: function () { - console.log("Set agent status to Available via Streams") - }, - failure: function () { - console.log("Failed to set agent status to Available via Streams") - } - }); - }); +const offlineState = agent.getAgentStates().find( + (state) => state.type === connect.AgentStateType.OFFLINE +); +agent.setState(offlineState, { + success: () => console.log("Agent state set to OFFLINE"), + failure: () => console.log("Failed to set agent state to OFFLINE""), +}, { enqueueNextState: true }); ``` -## Hang up call - +## Change Agent State to ROUTABLE +Set the agent state to ROUTABLE: +(The defalt routable state name is "Available" but you can edit it in the Admin Website) ```js - var c; - connect.contact(function (contact) { - c = contact; - connect.agent(async function(agent) { - if (c) { - var initialConnection = c.getInitialConnection(); - if (initialConnection) { - initialConnection.destroy(); - } - } - }); - }); +const routableState = agent.getAgentStates().find( + (state) => state.type === connect.AgentStateType.ROUTABLE +); +agent.setState(routableState, { + success: () => console.log(`Agent state set to ${routableState.name}`), + failure: () => console.log("Failed to set agent state to ROUTABLE"), +}, { enqueueNextState: true }); ``` -## Hang up second line +## Change Agent State to a Custom State +Change the agent state to a custom state: +```js +const targetCustomStateName = "your-custom-state"; +const customState = agent.getAgentStates().find( + (state) => state.name === targetCustomStateName +); +agent.setState(customState, { + success: () => console.log(`Agent state set to ${routableState.name}`), + failure: () => console.log(`Failed to set agent state to ${targetCustomStateName}`), +}, { enqueueNextState: true }); +``` +## Detect a New Contact Routed to the Agent +Listen for a new contact being routed to the agent: ```js - var c; - connect.contact(function (contact) { - c = contact; - connect.agent(async function(agent) { - if (c) { - var thirdParty = c.getSingleActiveThirdPartyConnection(); - if (thirdParty) { - thirdParty.destroy(); - } - } - }); - }); -``` - -## Hang up calls, set status to Offline and redirect to logout URL +connect.contact((contact) => { + const contactId = contact.getContactId(); + const initialContactId = contact.getInitialContactId(); + const type = contact.getType(); + const subType = contact.getContactSubtype(); + console.log("New contact detected:", { contactId, initialContactId, type, subType }); +}); +``` +## Show accept button for an incoming contact +Display an “Accept” button when an incoming contact arrives: ```js - var c; - var ccpInstance = "yourInstanceAlias"; - connect.contact(function (contact) { - c = contact; - connect.agent( function(agent) { - if (c) { - var initialConnection = c.getInitialConnection(); - var thirdParty = c.getSingleActiveThirdPartyConnection(); - if (initialConnection) { - initialConnection.destroy(); - await sleep(1000); - } - if (thirdParty) { - thirdParty.destroy(); - await sleep(1000); - } - } - }); - - var offlineState = agent.getAgentStates().filter(function (state) { - return state.type === connect.AgentStateType.OFFLINE; })[0]; - agent.setState(offlineState, { - success: function () { - console.log("Set agent status to Offline via Streams") - }, - failure: function () { - console.log("Failed to set agent status to Offline via Streams") - } - }); - - window.location.replace('https:///connect/logout'); - // or fetch("https:///connect/logout", { credentials: 'include'}) - }); -``` +connect.contact((contact) => { + contact.onRefresh((_contact) => { + if (shouldShowAcceptButton(_contact)) { + showAcceptButton(); // Your custom function to display the button + } else { + hideAcceptButton(); // Your custom function to hide the button + } + + function shouldShowAcceptButton(c) { + const contactStateType = c.getState().type; + const contactType = c.getType(); + const agentConnection = c.getAgentConnection(); + + if (contactType === connect.ContactType.QUEUE_CALLBACK || contactType === connect.ContactType.VOICE || contactType === connect.ContactType.CHAT) { + // Return false if this is a monitoring contact for supervisor. + // Monitoring contact is not supported for task and email channel. + const isMonitoringCall = agentConnection.getType() === connect.ConnectionType.MONITORING || Object.values(connect.MonitoringMode).includes(agentConnection.getMonitorStatus()?.toUpperCase()); + if (isMonitoringCall) return false; + } -## Dial a number + if (contactType === connect.ContactType.QUEUE_CALLBACK) { + // Queued callback contact comes in as "incoming" state. + return contactStateType === connect.ContactStateType.INCOMING; + } else if (contactType === connect.ContactType.VOICE) { + // Voice contact comes in as "connecting" state. Return true only if the contact is inbound and the agent is configured to use softphone, not deskphone. + return c.isSoftphoneCall() && c.isInbound() && contactStateType === connect.ContactStateType.CONNECTING; + } else if (contactStateType === connect.ContactStateType.CONNECTING) { + return true; + } -```js - var agent = new lily.Agent(); - agent.connect(connect.Endpoint.byPhoneNumber("14802021091"),{}); + return false; + } + }) +}); ``` -## Get quick connects - +## Disconnect Agent from a Contact +Terminate the agent’s connection to a contact: ```js - var agent = new lily.Agent(); - - agent.getEndpoints(agent.getAllQueueARNs(), { - success: function(data){ - console.log("valid_queue_phone_agent_endpoints", data.endpoints, "You can transfer the call to any of these endpoints"); - }, - failure:function(){ - console.log("failed") - } - }); +const agentConnection = contact.getAgentConnection(); +agentConnection.destroy({ + success: () => console.log("Disconnected from the contact"), + failure: () => console.log("Failed to disconnect from the contact"), +}); ``` -## Transfer to a quick connect - +## Disconnect Agent from a Contact and Clear the Contact +Disconnect and clear the contact when it ends: ```js - var agent = new lily.Agent(); - - agent.getEndpoints(agent.getAllQueueARNs(), { - success: function(data){ - console.log("valid_queue_phone_agent_endpoints", data.endpoints, "You can transfer the call to any of these endpoints"); - agent.getContacts(lily.ContactType.VOICE)[0].addConnection(data.endpoints[6], { - success: function(data) { - alert("transfer success"); - }, - failure: function(data) { - alert("transfer failed"); - } - }); - - }, - failure:function(){ - console.log("failed") - } - }); +const agentConnection = contact.getAgentConnection(); + +contact.onEnded((_contact) => { + _contact.clear({ + success: () => console.log("Contact cleared"), + failure: () => console.log("Failed to clear contact"), + }); +}); +// Don't call contact.clear in success callback as the backend would not be ready yet. Rather use contact.onEnded(). +agentConnection.destroy({ + success: () => console.log("Disconnected from the contact"), + failure: () => console.log("Failed to disconnect from the contact"), +}); ``` -## Transfer to a phone number - +## Get Quick Connect Endpoints of Default Outbound Queue +Fetch Quick Connect endpoints for all queues in the routing profile: ```js - var agent = new lily.Agent(); - var endpoint = connect.Endpoint.byPhoneNumber("+14807081026"); - - agent.getContacts(lily.ContactType.VOICE)[0].addConnection(endpoint, { - success: function(data) { - alert("transfer success"); - }, - failure: function(data) { - alert("transfer failed"); - } - }); +const defaultOutboundQueueARN = agent.getRoutingProfile().defaultOutboundQueue.queueARN; +agent.getEndpoints(defaultOutboundQueueARN, { + success: ({ endpoints }) => console.log("Retrieved Quick Connects", endpoints), + failure: () => console.log("Failed to retrieve quick connects"), +}); ``` -## Update agent config to use softphone - +## Get Quick Connect Endpoints of All Routing Profile Queues +Fetch Quick Connect endpoints for all queues in the routing profile: ```js - connect.agent(async function(agent) { - a = agent; - var config = a.getConfiguration(); - - //config.value = whatYouWant - config.softphoneEnabled = true; - a.setConfiguration(config, { - success: function() { - console.log("set softphone successfully"); - }, - failure: function() { - console.log("Could not set softphone...."); - }}); - }); +const routingProfileQueueARNs = agent.getAllQueueARNs(); +agent.getEndpoints(routingProfileQueueARNs, { + success: ({ endpoints }) => console.log("Retrieved Quick Connects", endpoints), + failure: () => console.log("Failed to retrieve quick connects"), +}); ``` -## Get contact attributes - +## Get Quick Connect Endpoints of the Current Contact’s Queue +Fetch Quick Connect endpoints for the queue associated with the current contact: ```js - var c; - connect.contact(function (contact) { - c = contact; - c.onConnecting(function (c) { - var attr = c.getAttributes(); - var c1 = c.getConnections()[1]; - var c2 = c.getStatus(); - document.getElementById("contactID").value = c.contactId; - document.getElementById("phoneNumber").value = c1.getAddress()['phoneNumber']; - if (attr.firstName) { - console.log (Here's your value for firstName " + attr.firstName.value); - } - if (attr.lastName) { - console.log (Here's your value for lastName " + attr.lastName.value); - } - }); - }); +const currentContactQueueARN = contact.getQueue().queueARN; +agent.getEndpoints(currentContactQueueARN, { + success: ({ endpoints }) => console.log("Retrieved Quick Connects", endpoints), + failure: () => console.log("Failed to retrieve quick connects"), +}); ``` -## Add a log message to agent logs - +## Get Combined Quick Connect Endpoints (Default Outbound Queue + Routing Profile Queues) +Fetch Quick Connect endpoints for the default outbound queue and all routing profile queues (Native CCP behavior): ```js - connect.getLog().warn("yar, I'm a pirate") +const defaultOutboundQueueARN = agent.getRoutingProfile().defaultOutboundQueue.queueARN; +const routingProfileQueueARNs = agent.getAllQueueARNs(); +agent.getEndpoints(routingProfileQueueARNs.concat(defaultOutboundQueueARN), { + success: ({ endpoints }) => console.log("Retrieved Quick Connects", endpoints), + failure: () => console.log("Failed to retrieve quick connects"), +}); ``` -## Download agent logs - +## Start an Outbound Call by Number +Initiate an outbound call using a phone number: ```js - connect.getLog().download() +const endpoint = connect.Endpoint.byPhoneNumber("+18005550100"); +agent.connect(endpoint, { + success: () => console.log("Started an outbound call"), + failure: () => console.log("Failed to start an outbound call"), +}); ``` -## Media Controller API for chat - ***New,ChatJS Required*** +## Filter External Quick Connect Endpoints and Start an Outbound Call +Filter external Quick Connect endpoints of the default outbound queue and start a call: +```js +const filteredEndpoints = endpoints.filter((endpoint) => endpoint.type === connect.AddressType.PHONE_NUMBER); + +// Select an endpoint +const endpoint = filteredEndpoints[0]; +agent.connect(endpoint, { + success: () => console.log("Started an outbound call"), + failure: () => console.log("Failed to start an outbound call"), +}); +``` +## Set Agent to Offline and Logout +Set the agent state to OFFLINE and log out: ```js - connect.contact(function(contact){ - contact.getAgentConnections().forEach(function(connection){ - // chat users - if(connection.getMediaType() === connect.MediaType.CHAT){ - contact.getConnection().getMediaController() - .then(function(controller){ - controller.onMessage(function(response){ - console.log("data", response) - }) - - controller.sendMessage({message: "so and so", contentType: "text/plain"}) - .then(function(res, req){ - console.log(res.status) - }); - - controller.onDisconnect(function(){ - console.log("on disconnect"); - }) - }); - } +function handleLogoutButtonClick() { + const agent = new connect.Agent(); + if (agent.getState().type === connect.AgentStatusType.OFFLINE) { + logout(); + } else { + setAgentOffline() + .then(logout) + .catch(console.error); + } +} + +function setAgentOffline() { + return new Promise((resolve, reject) => { + const agent = new connect.Agent(); + const offlineState = agent.getAgentStates().find( + (state) => state.type === connect.AgentStateType.OFFLINE, + ); + agent.setState(offlineState, { + success: resolve, + failure: reject, + }, { enqueueNextState: true }); + }); +} + +function logout() { + const logoutEndpoint = "https:///logout"; + fetch(logoutEndpoint, { credentials: 'include', mode: 'no-cors'}) + .then(() => { + // Notify all CCPs to terminate + connect.core.getUpstream().sendUpstream(connect.EventType.TERMINATE); }); +} ``` - -## ViewContact API - + +## Update Agent Configuration to Use Softphone +Enable softphone for the agent: ```js - connect.core.viewContact("contactID") +const config = agent.getConfiguration(); +const newConfig = { + ...config, + softphoneEnabled: true, +}; + +agent.setConfiguration(newConfig, { + success: () => console.log("Updated agent configuration"), + failure: () => console.log("Failed to update agent configuration"), +}); ``` -## onAuthFail Event Handler - +## Update Agent’s Extension Number +Change the agent’s extension number: ```js - connect.core.onAuthFail(function(){ - // agent logged out or session expired. needs login - // show button for login or popup a login screen. - }); +const config = agent.getConfiguration(); +const newConfig = { + ...config, + softphoneEnabled: false, + extension: "+11234567890", +}; + +agent.setConfiguration(newConfig, { + success: () => console.log("Updated agent configuration"), + failure: () => console.log("Failed to update agent configuration"), +}); ``` -## onSoftphoneSessionInit Event Handler - +## Update Agent’s Language Preference +Set the agent’s preferred language: ```js - connect.core.onSoftphoneSessionInit(function({ connectionId }) { - var softphoneManager = connect.core.getSoftphoneManager(); - if(softphoneManager){ - // access session - var session = softphoneManager.getSession(connectionId); - // YOu can use this rtc session for stats analysis - } - }); +const config = agent.getConfiguration(); +const newConfig = { + ...config, + agentPreferences: { + locale: "en_US", + }, +}; + +agent.setConfiguration(newConfig, { + success: () => console.log("Updated agent configuration"), + failure: () => console.log("Failed to update agent configuration"), +}); ``` -## fetch API +## Change Audio Device Settings +Manage audio devices (microphone, speaker, ringer). The process varies based on the softphone configuration: -```js - connect.fetch("endpoint", options, retryinterval, maxRetry); -``` +Device IDs are unique to their origin, so the method for obtaining microphone and speaker device IDs depends on where the WebRTC communication occurs. If you initialize the CCP with `allowFramedSoftphone: true`, use the `connect.core.getFrameMediaDevices()` API to retrieve device IDs from the embedded CCP context in the Connect domain. However, ringer device IDs should always be obtained from the embedded CCP context using the same API, as ringtones are played there regardless of the `allowFramedSoftphone` parameter. -## Mute Agent - +### For Framed Softphone Users (`allowFramedSoftphone: true`) +For those who call initCCP with `allowFramedSoftphone: true`: ```js - function muteAgent(){ - const agent = new connect.Agent(); - const contact = agent.getContacts(connect.ContactType.VOICE)?.[0] - - // Get all open active connections - const activeConnections = contact?.getConnections().filter((conn) => conn.isActive()) || []; - - - if (activeConnections.length === 0) { - console.log("No Active Connections to mute"); - return; - } - - // Check if we are using multiparty and see if there more than 2 active connections - if (contact.isMultiPartyConferenceEnabled() && activeConnections.length > 2) { - // if any of those are in connecting mode - const connectingConnections = contact?.getConnections().filter((conn) => conn.isConnecting()) || []; - if (connectingConnections.length === 0) { - console.log("Agent Connection is muted at the server side"); - contact.getAgentConnection().muteParticipant(); - } else { - console.log("Agent Connection cannot be muted while multi party participant is connecting") - } - } else { - console.log("Agent connection muted at the client side"); - agent.mute(); - } - } +const deviceList = await connect.core.getFrameMediaDevices(); +const audioInputDevices = deviceList.filter(device => device.kind === 'audioinput'); +const audioOutputDevices = deviceList.filter(device => device.kind === 'audiooutput'); + +// Agent-selected devices +const targetMicrophoneDeviceId = audioInputDevices[0].deviceId; +const targetSpeakerDeviceId = audioOutputDevices[0].deviceId; +const targetRingerDeviceId = audioOutputDevices[0].deviceId; + +// Setting speaker and ringer devices can work anytime. +agent.setSpeakerDevice(targetSpeakerDeviceId); +agent.setRingerDevice(targetRingerDeviceId); + +// The setMicrophoneDevice method can only be used when there is an active softphone contact, so it should be called within the onLocalMediaStreamCreated callback. +// If you need to call agent.onLocalMediaStreamCreated multiple times, ensure you unsubscribe from the previous callback before registering a new one to prevent setMicrophoneDevice from being called redundantly. +agent.onLocalMediaStreamCreated(() => { + agent.setMicrophoneDevice(targetMicrophoneDeviceId); +}); ``` -## Check if connected contact has ScreenRecording Enabled +### For Custom Softphone Users (`allowFramedSoftphone: false`) +For those who load RTCJS, call initCCP with `allowFramedSoftphone: false`, and call `connect.core.initSoftphoneManager()`: ```js - connect.contact(function (contact) { - contact.onConnected(function (connectedContact) { - const isScreenRecordingEnabled = connectedContact.getContactFeatures()?.screenRecordingConfig?.screenRecordingEnabled ?? false - console.log(`contact isScreenRecordingEnabled: ${isScreenRecordingEnabled}`) - }); - }); -``` +const deviceListFromConnectDomain = await connect.core.getFrameMediaDevices(); +const audioInputDevicesFromConnectDomain = deviceListFromConnectDomain.filter(device => device.kind === 'audioinput'); +const audioOutputDevicesFromConnectDomain = deviceListFromConnectDomain.filter(device => device.kind === 'audiooutput'); + +const deviceListFromMyDomain = await navigator.mediaDevices.enumerateDevices(); +const audioOutputDevicesFromMyDomain = deviceListFromMyDomain.filter(device => device.kind === 'audiooutput'); + +// Agent-selected devices +const targetMicrophoneDeviceId = audioInputDevicesFromConnectDomain[0].deviceId; +const targetSpeakerDeviceId = audioOutputDevicesFromConnectDomain[0].deviceId; +const targetRingerDeviceId = audioOutputDevicesFromMyDomain[0].deviceId; + +// Setting speaker and ringer devices can work anytime. +agent.setSpeakerDevice(targetSpeakerDeviceId); +agent.setRingerDevice(targetRingerDeviceId); + +// The setMicrophoneDevice method can only be used when there is an active softphone contact, so it should be called within the onLocalMediaStreamCreated callback. +// If you need to call agent.onLocalMediaStreamCreated multiple times, ensure you unsubscribe from the previous callback before registering a new one to prevent setMicrophoneDevice from being called redundantly. +agent.onLocalMediaStreamCreated(() => { + agent.setMicrophoneDevice(targetMicrophoneDeviceId); +}); +``` \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 49588bb..0d3bad3 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "amazon-connect-streams", - "version": "2.17.0", + "version": "2.18.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "amazon-connect-streams", - "version": "2.17.0", + "version": "2.18.0", "license": "Apache-2.0", "dependencies": { "@amazon-connect/core": "1.0.4", @@ -96,9 +96,9 @@ } }, "node_modules/@babel/compat-data": { - "version": "7.26.2", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.2.tgz", - "integrity": "sha512-Z0WgzSEa+aUcdiJuCIqgujCshpMWgUpgOxXotrYPSA53hA3qopNaqcJpyr0hVb1FeWdnqFA35/fUtXgBK8srQg==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.26.3.tgz", + "integrity": "sha512-nHIxvKPniQXpmQLb0vhY3VaFb3S0YrTAwpOWJZh1wn3oJPjJk9Asva204PsBdmAE8vpzfHudT8DB0scYvy9q0g==", "dev": true, "engines": { "node": ">=6.9.0" @@ -153,13 +153,13 @@ } }, "node_modules/@babel/generator": { - "version": "7.26.2", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.2.tgz", - "integrity": "sha512-zevQbhbau95nkoxSq3f/DC/SC+EEOUZd3DYqfSkMhY2/wfSeaHV1Ew4vk8e+x8lja31IbyuUa2uQ3JONqKbysw==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.3.tgz", + "integrity": "sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==", "dev": true, "dependencies": { - "@babel/parser": "^7.26.2", - "@babel/types": "^7.26.0", + "@babel/parser": "^7.26.3", + "@babel/types": "^7.26.3", "@jridgewell/gen-mapping": "^0.3.5", "@jridgewell/trace-mapping": "^0.3.25", "jsesc": "^3.0.2" @@ -180,19 +180,6 @@ "node": ">=6.9.0" } }, - "node_modules/@babel/helper-builder-binary-assignment-operator-visitor": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.25.9.tgz", - "integrity": "sha512-C47lC7LIDCnz0h4vai/tpNOI95tCd5ZT3iBt/DBH5lXKHZsyNQv18yf1wIIg2ntiQNgmAvA+DgZ82iW8Qdym8g==", - "dev": true, - "dependencies": { - "@babel/traverse": "^7.25.9", - "@babel/types": "^7.25.9" - }, - "engines": { - "node": ">=6.9.0" - } - }, "node_modules/@babel/helper-compilation-targets": { "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.25.9.tgz", @@ -231,13 +218,13 @@ } }, "node_modules/@babel/helper-create-regexp-features-plugin": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.25.9.tgz", - "integrity": "sha512-ORPNZ3h6ZRkOyAa/SaHU+XsLZr0UQzRwuDQ0cczIA17nAzZ+85G5cVkOJIj7QavLZGSe8QXUmNFxSZzjcZF9bw==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.26.3.tgz", + "integrity": "sha512-G7ZRb40uUgdKOQqPLjfD12ZmGA54PzqDFUv2BKImnC9QIfGhIHKvVML0oN8IUiDq4iRqpq74ABpvOaerfWdong==", "dev": true, "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", - "regexpu-core": "^6.1.1", + "regexpu-core": "^6.2.0", "semver": "^6.3.1" }, "engines": { @@ -361,19 +348,6 @@ "@babel/core": "^7.0.0" } }, - "node_modules/@babel/helper-simple-access": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.25.9.tgz", - "integrity": "sha512-c6WHXuiaRsJTyHYLJV75t9IqsmTbItYfdj99PnzYGQZkYKvan5/2jKJ7gu31J3/BJ/A18grImSPModuyG/Eo0Q==", - "dev": true, - "dependencies": { - "@babel/traverse": "^7.25.9", - "@babel/types": "^7.25.9" - }, - "engines": { - "node": ">=6.9.0" - } - }, "node_modules/@babel/helper-skip-transparent-expression-wrappers": { "version": "7.25.9", "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.25.9.tgz", @@ -442,12 +416,12 @@ } }, "node_modules/@babel/parser": { - "version": "7.26.2", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.2.tgz", - "integrity": "sha512-DWMCZH9WA4Maitz2q21SRKHo9QXZxkDsbNZoVD62gusNtNBBqDg9i7uOhASfTfIGNzW+O+r7+jAlM8dwphcJKQ==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz", + "integrity": "sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==", "dev": true, "dependencies": { - "@babel/types": "^7.26.0" + "@babel/types": "^7.26.3" }, "bin": { "parser": "bin/babel-parser.js" @@ -1025,12 +999,11 @@ } }, "node_modules/@babel/plugin-transform-exponentiation-operator": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.25.9.tgz", - "integrity": "sha512-KRhdhlVk2nObA5AYa7QMgTMTVJdfHprfpAk4DjZVtllqRg9qarilstTKEhpVjyt+Npi8ThRyiV8176Am3CodPA==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.26.3.tgz", + "integrity": "sha512-7CAHcQ58z2chuXPWblnn1K6rLDnDWieghSOEmqQsrBenH0P9InCUtOJYD89pvngljmZlJcz3fcmgYsXFNGa1ZQ==", "dev": true, "dependencies": { - "@babel/helper-builder-binary-assignment-operator-visitor": "^7.25.9", "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { @@ -1165,14 +1138,13 @@ } }, "node_modules/@babel/plugin-transform-modules-commonjs": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.25.9.tgz", - "integrity": "sha512-dwh2Ol1jWwL2MgkCzUSOvfmKElqQcuswAZypBSUsScMXvgdT8Ekq5YA6TtqpTVWH+4903NmboMuH1o9i8Rxlyg==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.26.3.tgz", + "integrity": "sha512-MgR55l4q9KddUDITEzEFYn5ZsGDXMSsU9E+kh7fjRXTIC3RHqfCo8RPRbyReYJh44HQ/yomFkqbOFohXvDCiIQ==", "dev": true, "dependencies": { - "@babel/helper-module-transforms": "^7.25.9", - "@babel/helper-plugin-utils": "^7.25.9", - "@babel/helper-simple-access": "^7.25.9" + "@babel/helper-module-transforms": "^7.26.0", + "@babel/helper-plugin-utils": "^7.25.9" }, "engines": { "node": ">=6.9.0" @@ -1527,9 +1499,9 @@ } }, "node_modules/@babel/plugin-transform-typescript": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.25.9.tgz", - "integrity": "sha512-7PbZQZP50tzv2KGGnhh82GSyMB01yKY9scIjf1a+GfZCtInOWqUH5+1EBU4t9fyR5Oykkkc9vFTs4OHrhHXljQ==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typescript/-/plugin-transform-typescript-7.26.3.tgz", + "integrity": "sha512-6+5hpdr6mETwSKjmJUdYw0EIkATiQhnELWlE3kJFBwSg/BGIVwVaVbX+gOXBCdc7Ln1RXZxyWGecIXhUfnl7oA==", "dev": true, "dependencies": { "@babel/helper-annotate-as-pure": "^7.25.9", @@ -1751,16 +1723,16 @@ } }, "node_modules/@babel/traverse": { - "version": "7.25.9", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.25.9.tgz", - "integrity": "sha512-ZCuvfwOwlz/bawvAuvcj8rrithP2/N55Tzz342AkTvq4qaWbGfmCk/tKhNaV2cthijKrPAA8SRJV5WWe7IBMJw==", + "version": "7.26.4", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.26.4.tgz", + "integrity": "sha512-fH+b7Y4p3yqvApJALCPJcwb0/XaOSgtK4pzV6WVjPR5GLFQBRI7pfoX2V2iM48NXvX07NUxxm1Vw98YjqTcU5w==", "dev": true, "dependencies": { - "@babel/code-frame": "^7.25.9", - "@babel/generator": "^7.25.9", - "@babel/parser": "^7.25.9", + "@babel/code-frame": "^7.26.2", + "@babel/generator": "^7.26.3", + "@babel/parser": "^7.26.3", "@babel/template": "^7.25.9", - "@babel/types": "^7.25.9", + "@babel/types": "^7.26.3", "debug": "^4.3.1", "globals": "^11.1.0" }, @@ -1769,9 +1741,9 @@ } }, "node_modules/@babel/types": { - "version": "7.26.0", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.0.tgz", - "integrity": "sha512-Z/yiTPj+lDVnF7lWeKCIJzaIkI0vYO87dMpZ4bg4TDrFe4XXLFWL1TbXU27gBP3QccxV9mZICCrnjnYlJjXHOA==", + "version": "7.26.3", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz", + "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==", "dev": true, "dependencies": { "@babel/helper-string-parser": "^7.25.9", @@ -2279,9 +2251,9 @@ } }, "node_modules/@jridgewell/gen-mapping": { - "version": "0.3.5", - "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz", - "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==", + "version": "0.3.8", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz", + "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==", "dev": true, "dependencies": { "@jridgewell/set-array": "^1.2.1", @@ -2567,9 +2539,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "22.10.1", - "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.1.tgz", - "integrity": "sha512-qKgsUwfHZV2WCWLAnVP1JqnpE6Im6h3Y0+fYgMTasNQ7V++CBX5OT1as0g0f+OyubbFqhf6XVNIsmN4IIhEgGQ==", + "version": "22.10.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.10.2.tgz", + "integrity": "sha512-Xxr6BBRCAOQixvonOye19wnzyDiUtTeqldOOmj3CkeblonbccA12PFwlufvRdrpjXxqnmUaeiU5EOA+7s5diUQ==", "dev": true, "dependencies": { "undici-types": "~6.20.0" @@ -2839,9 +2811,9 @@ } }, "node_modules/@ungap/structured-clone": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz", - "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz", + "integrity": "sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==", "dev": true }, "node_modules/@webassemblyjs/ast": { @@ -3345,15 +3317,15 @@ } }, "node_modules/array.prototype.flat": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.2.tgz", - "integrity": "sha512-djYB+Zx2vLewY8RWlNCUdHjDXs2XOgm602S9E7P/UpHgfeHL00cRiIF+IN/G/aUJ7kGPb6yO/ErDI5V2s8iycA==", + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flat/-/array.prototype.flat-1.3.3.tgz", + "integrity": "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -3363,15 +3335,15 @@ } }, "node_modules/array.prototype.flatmap": { - "version": "1.3.2", - "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.2.tgz", - "integrity": "sha512-Ewyx0c9PmpcsByhSW4r+9zDU7sGjFc86qf/kKtuSCRdhfbk0SNLLkaT5qvcHnRGgc5NP/ly/y+qkXkqONX54CQ==", + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.3.3.tgz", + "integrity": "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "es-shim-unscopables": "^1.0.0" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.5", + "es-shim-unscopables": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -3381,19 +3353,18 @@ } }, "node_modules/arraybuffer.prototype.slice": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.3.tgz", - "integrity": "sha512-bMxMKAjg13EBSVscxTaYA4mRc5t1UAXa2kXiGTNfZ079HIWXEkKmkgFrh/nJqamaLSrXO5H4WFFkPEaLJWbs3A==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/arraybuffer.prototype.slice/-/arraybuffer.prototype.slice-1.0.4.tgz", + "integrity": "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ==", "dev": true, "dependencies": { "array-buffer-byte-length": "^1.0.1", - "call-bind": "^1.0.5", + "call-bind": "^1.0.8", "define-properties": "^1.2.1", - "es-abstract": "^1.22.3", - "es-errors": "^1.2.1", - "get-intrinsic": "^1.2.3", - "is-array-buffer": "^3.0.4", - "is-shared-array-buffer": "^1.0.2" + "es-abstract": "^1.23.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6", + "is-array-buffer": "^3.0.4" }, "engines": { "node": ">= 0.4" @@ -3695,9 +3666,9 @@ "dev": true }, "node_modules/browserslist": { - "version": "4.24.2", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.2.tgz", - "integrity": "sha512-ZIc+Q62revdMcqC6aChtW4jz3My3klmCO1fEmINZY/8J3EpBg5/A/D0AKmBveUh6pgoeycoMkVMko84tuYS+Gg==", + "version": "4.24.3", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.24.3.tgz", + "integrity": "sha512-1CPmv8iobE2fyRMV97dAcMVegvvWKxmq94hkLiAkUGwKVTyDLw33K+ZxiFrREKmmps4rIw6grcCFCnTMSZ/YiA==", "dev": true, "funding": [ { @@ -3714,9 +3685,9 @@ } ], "dependencies": { - "caniuse-lite": "^1.0.30001669", - "electron-to-chromium": "^1.5.41", - "node-releases": "^2.0.18", + "caniuse-lite": "^1.0.30001688", + "electron-to-chromium": "^1.5.73", + "node-releases": "^2.0.19", "update-browserslist-db": "^1.1.1" }, "bin": { @@ -3784,16 +3755,44 @@ } }, "node_modules/call-bind": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz", - "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz", + "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==", "dev": true, "dependencies": { + "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", - "es-errors": "^1.3.0", - "function-bind": "^1.1.2", "get-intrinsic": "^1.2.4", - "set-function-length": "^1.2.1" + "set-function-length": "^1.2.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/call-bind-apply-helpers": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz", + "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/call-bound": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz", + "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==", + "dev": true, + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -3821,9 +3820,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001684", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001684.tgz", - "integrity": "sha512-G1LRwLIQjBQoyq0ZJGqGIJUXzJ8irpbjHLpVRXDvBEScFJ9b17sgK6vlx0GAJFE21okD7zXl08rRRUfq6HdoEQ==", + "version": "1.0.30001689", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001689.tgz", + "integrity": "sha512-CmeR2VBycfa+5/jOfnp/NpWPGd06nf1XYiefUvhXFfZE4GkRc9jv+eGPS4nT558WS/8lYCzV8SlANCIPvbWP1g==", "dev": true, "funding": [ { @@ -4275,9 +4274,9 @@ "dev": true }, "node_modules/debug": { - "version": "4.3.7", - "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz", - "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==", + "version": "4.4.0", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz", + "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==", "dev": true, "dependencies": { "ms": "^2.1.3" @@ -4516,6 +4515,20 @@ "domelementtype": "1" } }, + "node_modules/dunder-proto": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz", + "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==", + "dev": true, + "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "es-errors": "^1.3.0", + "gopd": "^1.2.0" + }, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/ecc-jsbn": { "version": "0.1.2", "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz", @@ -4527,9 +4540,9 @@ } }, "node_modules/electron-to-chromium": { - "version": "1.5.67", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.67.tgz", - "integrity": "sha512-nz88NNBsD7kQSAGGJyp8hS6xSPtWwqNogA0mjtc2nUYeEf3nURK9qpV18TuBdDmEDgVWotS8Wkzf+V52dSQ/LQ==", + "version": "1.5.74", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.74.tgz", + "integrity": "sha512-ck3//9RC+6oss/1Bh9tiAVFy5vfSKbRHAFh7Z3/eTRkEqJeWgymloShB17Vg3Z4nmDNp35vAd1BZ6CMW4Wt6Iw==", "dev": true }, "node_modules/emittery": { @@ -4600,57 +4613,59 @@ } }, "node_modules/es-abstract": { - "version": "1.23.5", - "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.5.tgz", - "integrity": "sha512-vlmniQ0WNPwXqA0BnmwV3Ng7HxiGlh6r5U6JcTMNx8OilcAGqVJBHJcPjqOMaczU9fRuRK5Px2BdVyPRnKMMVQ==", + "version": "1.23.6", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.23.6.tgz", + "integrity": "sha512-Ifco6n3yj2tMZDWNLyloZrytt9lqqlwvS83P3HtaETR0NUOYnIULGGHpktqYGObGy+8wc1okO25p8TjemhImvA==", "dev": true, "dependencies": { "array-buffer-byte-length": "^1.0.1", - "arraybuffer.prototype.slice": "^1.0.3", + "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", "data-view-buffer": "^1.0.1", "data-view-byte-length": "^1.0.1", "data-view-byte-offset": "^1.0.0", - "es-define-property": "^1.0.0", + "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "es-set-tostringtag": "^2.0.3", - "es-to-primitive": "^1.2.1", - "function.prototype.name": "^1.1.6", - "get-intrinsic": "^1.2.4", + "es-to-primitive": "^1.3.0", + "function.prototype.name": "^1.1.7", + "get-intrinsic": "^1.2.6", "get-symbol-description": "^1.0.2", "globalthis": "^1.0.4", - "gopd": "^1.0.1", + "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", - "has-proto": "^1.0.3", - "has-symbols": "^1.0.3", + "has-proto": "^1.2.0", + "has-symbols": "^1.1.0", "hasown": "^2.0.2", - "internal-slot": "^1.0.7", + "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.4", "is-callable": "^1.2.7", - "is-data-view": "^1.0.1", + "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", - "is-regex": "^1.1.4", + "is-regex": "^1.2.1", "is-shared-array-buffer": "^1.0.3", - "is-string": "^1.0.7", + "is-string": "^1.1.1", "is-typed-array": "^1.1.13", - "is-weakref": "^1.0.2", + "is-weakref": "^1.1.0", + "math-intrinsics": "^1.0.0", "object-inspect": "^1.13.3", "object-keys": "^1.1.1", "object.assign": "^4.1.5", "regexp.prototype.flags": "^1.5.3", - "safe-array-concat": "^1.1.2", - "safe-regex-test": "^1.0.3", - "string.prototype.trim": "^1.2.9", - "string.prototype.trimend": "^1.0.8", + "safe-array-concat": "^1.1.3", + "safe-regex-test": "^1.1.0", + "string.prototype.trim": "^1.2.10", + "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.2", "typed-array-byte-length": "^1.0.1", - "typed-array-byte-offset": "^1.0.2", - "typed-array-length": "^1.0.6", + "typed-array-byte-offset": "^1.0.3", + "typed-array-length": "^1.0.7", "unbox-primitive": "^1.0.2", - "which-typed-array": "^1.1.15" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -4660,13 +4675,10 @@ } }, "node_modules/es-define-property": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz", - "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==", + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz", + "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==", "dev": true, - "dependencies": { - "get-intrinsic": "^1.2.4" - }, "engines": { "node": ">= 0.4" } @@ -5633,15 +5645,16 @@ } }, "node_modules/function.prototype.name": { - "version": "1.1.6", - "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.6.tgz", - "integrity": "sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==", + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/function.prototype.name/-/function.prototype.name-1.1.7.tgz", + "integrity": "sha512-2g4x+HqTJKM9zcJqBSpjoRmdcPFtJM60J3xJisTQSXBWka5XqyBN/2tNUgma1mztTXyDuUsEtYe5qcs7xYzYQA==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "define-properties": "^1.2.0", - "es-abstract": "^1.22.1", - "functions-have-names": "^1.2.3" + "call-bind": "^1.0.8", + "define-properties": "^1.2.1", + "functions-have-names": "^1.2.3", + "hasown": "^2.0.2", + "is-callable": "^1.2.7" }, "engines": { "node": ">= 0.4" @@ -5687,16 +5700,21 @@ } }, "node_modules/get-intrinsic": { - "version": "1.2.4", - "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz", - "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==", + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.6.tgz", + "integrity": "sha512-qxsEs+9A+u85HhllWJJFicJfPDhRmjzoYdl64aMWW9yRIJmSyxdn8IEkuIM530/7T+lv0TIHd8L6Q/ra0tEoeA==", "dev": true, "dependencies": { + "call-bind-apply-helpers": "^1.0.1", + "dunder-proto": "^1.0.0", + "es-define-property": "^1.0.1", "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", "function-bind": "^1.1.2", - "has-proto": "^1.0.1", - "has-symbols": "^1.0.3", - "hasown": "^2.0.0" + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.0.0" }, "engines": { "node": ">= 0.4" @@ -5727,14 +5745,14 @@ } }, "node_modules/get-symbol-description": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.0.2.tgz", - "integrity": "sha512-g0QYk1dZBxGwk+Ngc+ltRH2IBp2f7zBkBMBJZCDerh6EhlhSR6+9irMCuT/09zD6qkarHUSn529sK/yL4S27mg==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz", + "integrity": "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg==", "dev": true, "dependencies": { - "call-bind": "^1.0.5", + "call-bound": "^1.0.3", "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.4" + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -5837,12 +5855,12 @@ } }, "node_modules/gopd": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz", - "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz", + "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==", "dev": true, - "dependencies": { - "get-intrinsic": "^1.1.3" + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -5914,10 +5932,13 @@ } }, "node_modules/has-proto": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz", - "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==", + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.2.0.tgz", + "integrity": "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ==", "dev": true, + "dependencies": { + "dunder-proto": "^1.0.0" + }, "engines": { "node": ">= 0.4" }, @@ -5926,9 +5947,9 @@ } }, "node_modules/has-symbols": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz", - "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz", + "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==", "dev": true, "engines": { "node": ">= 0.4" @@ -6163,14 +6184,14 @@ "dev": true }, "node_modules/internal-slot": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.7.tgz", - "integrity": "sha512-NGnrKwXzSms2qUUih/ILZ5JBqNTSa1+ZmP6flaIp6KmSElgE9qdndzS3cqjrDovwFdmwsGsLdeFgB6suw+1e9g==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.1.0.tgz", + "integrity": "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw==", "dev": true, "dependencies": { "es-errors": "^1.3.0", - "hasown": "^2.0.0", - "side-channel": "^1.0.4" + "hasown": "^2.0.2", + "side-channel": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -6186,13 +6207,14 @@ } }, "node_modules/is-array-buffer": { - "version": "3.0.4", - "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.4.tgz", - "integrity": "sha512-wcjaerHw0ydZwfhiKbXJWLDY8A7yV7KhjQOpb83hGgGfId/aQa4TOvwyzn2PuswW2gPCYEL/nEAiSVpdOj1lXw==", + "version": "3.0.5", + "resolved": "https://registry.npmjs.org/is-array-buffer/-/is-array-buffer-3.0.5.tgz", + "integrity": "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "get-intrinsic": "^1.2.1" + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -6223,12 +6245,15 @@ } }, "node_modules/is-bigint": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.4.tgz", - "integrity": "sha512-zB9CruMamjym81i2JZ3UMn54PKGsQzsJeo6xvN3HJJ4CAsQNB6iRutp2To77OfCNuoxspsIhzaPoO1zyCEhFOg==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.1.0.tgz", + "integrity": "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ==", "dev": true, "dependencies": { - "has-bigints": "^1.0.1" + "has-bigints": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -6247,13 +6272,13 @@ } }, "node_modules/is-boolean-object": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.2.tgz", - "integrity": "sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.2.1.tgz", + "integrity": "sha512-l9qO6eFlUETHtuihLcYOaLKByJ1f+N4kthcU9YjHy3N+B3hWv0y/2Nd0mu/7lTFnRQHTrSdXF50HQ3bl5fEnng==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6275,9 +6300,9 @@ } }, "node_modules/is-core-module": { - "version": "2.15.1", - "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.15.1.tgz", - "integrity": "sha512-z0vtXSwucUJtANQWldhbtbt7BnL0vxiFjIdDLAatwhDYty2bad6s+rijD6Ri4YuYJubLzIJLUidCh09e1djEVQ==", + "version": "2.16.0", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.0.tgz", + "integrity": "sha512-urTSINYfAYgcbLb0yDQ6egFm6h3Mo1DcF9EkyXSRjjzdHbsulg01qhwWuXdOoUBuTkbQ80KDboXa0vFJ+BDH+g==", "dev": true, "dependencies": { "hasown": "^2.0.2" @@ -6290,11 +6315,13 @@ } }, "node_modules/is-data-view": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.1.tgz", - "integrity": "sha512-AHkaJrsUVW6wq6JS8y3JnM/GJF/9cf+k20+iDzlSaJrinEo5+7vRiteOSwBhHRiAyQATN1AmY4hwzxJKPmYf+w==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-data-view/-/is-data-view-1.0.2.tgz", + "integrity": "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw==", "dev": true, "dependencies": { + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" }, "engines": { @@ -6305,12 +6332,13 @@ } }, "node_modules/is-date-object": { - "version": "1.0.5", - "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.5.tgz", - "integrity": "sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.1.0.tgz", + "integrity": "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg==", "dev": true, "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6329,12 +6357,12 @@ } }, "node_modules/is-finalizationregistry": { - "version": "1.1.0", - "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.0.tgz", - "integrity": "sha512-qfMdqbAQEwBw78ZyReKnlA8ezmPdb9BemzIIip/JkjaZUhitfXDkkr+3QTboW0JrSXT1QWyYShpvnNHGZ4c4yA==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-finalizationregistry/-/is-finalizationregistry-1.1.1.tgz", + "integrity": "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg==", "dev": true, "dependencies": { - "call-bind": "^1.0.7" + "call-bound": "^1.0.3" }, "engines": { "node": ">= 0.4" @@ -6422,12 +6450,13 @@ } }, "node_modules/is-number-object": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.7.tgz", - "integrity": "sha512-k1U0IRzLMo7ZlYIfzRu23Oh6MiIFasgpb9X76eqfFZAqwH44UI4KTBvBYIZ1dSL9ZzChTB9ShHfLkR4pdW5krQ==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.1.1.tgz", + "integrity": "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw==", "dev": true, "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6476,13 +6505,15 @@ } }, "node_modules/is-regex": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.4.tgz", - "integrity": "sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.2.1.tgz", + "integrity": "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.2", + "gopd": "^1.2.0", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.2" }, "engines": { "node": ">= 0.4" @@ -6531,12 +6562,13 @@ } }, "node_modules/is-string": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", - "integrity": "sha512-tE2UXzivje6ofPW7l23cjDOMa09gb7xlAqG6jG5ej6uPV32TlWP3NKPigtaGeHNu9fohccRYvIiZMfOOnOYUtg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.1.1.tgz", + "integrity": "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA==", "dev": true, "dependencies": { - "has-tostringtag": "^1.0.0" + "call-bound": "^1.0.3", + "has-tostringtag": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -6546,12 +6578,14 @@ } }, "node_modules/is-symbol": { - "version": "1.0.4", - "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz", - "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.1.1.tgz", + "integrity": "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w==", "dev": true, "dependencies": { - "has-symbols": "^1.0.2" + "call-bound": "^1.0.2", + "has-symbols": "^1.1.0", + "safe-regex-test": "^1.1.0" }, "engines": { "node": ">= 0.4" @@ -6561,12 +6595,12 @@ } }, "node_modules/is-typed-array": { - "version": "1.1.13", - "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz", - "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==", + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.14.tgz", + "integrity": "sha512-lQUsHzcTb7rH57dajbOuZEuMDXjs9f04ZloER4QOpjpKcaw4f98BRUrs8aiO9Z4G7i7B0Xhgarg6SCgYcYi8Nw==", "dev": true, "dependencies": { - "which-typed-array": "^1.1.14" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" @@ -6606,25 +6640,28 @@ } }, "node_modules/is-weakref": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.0.2.tgz", - "integrity": "sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-weakref/-/is-weakref-1.1.0.tgz", + "integrity": "sha512-SXM8Nwyys6nT5WP6pltOwKytLV7FqQ4UiibxVmW+EIosHcmCqkkjViTb5SNssDlkCiEYRP1/pdWUKVvZBmsR2Q==", "dev": true, "dependencies": { - "call-bind": "^1.0.2" + "call-bound": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/is-weakset": { - "version": "2.0.3", - "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.3.tgz", - "integrity": "sha512-LvIm3/KWzS9oRFHugab7d+M/GcBXuXX5xZkzPmN+NxihdQlZUQ4dWuSV1xR/sq6upL1TJEDrfBgRepHFdBtSNQ==", + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/is-weakset/-/is-weakset-2.0.4.tgz", + "integrity": "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", - "get-intrinsic": "^1.2.4" + "call-bound": "^1.0.3", + "get-intrinsic": "^1.2.6" }, "engines": { "node": ">= 0.4" @@ -7403,9 +7440,9 @@ } }, "node_modules/jsesc": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", - "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", "dev": true, "bin": { "jsesc": "bin/jsesc" @@ -7714,6 +7751,15 @@ "tmpl": "1.0.5" } }, + "node_modules/math-intrinsics": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.0.0.tgz", + "integrity": "sha512-4MqMiKP90ybymYvsut0CH2g4XWbfLtmlCkXmtmdcDCxNB+mQcu1w/1+L/VD7vi/PSv7X2JYV7SCcR+jiPXnQtA==", + "dev": true, + "engines": { + "node": ">= 0.4" + } + }, "node_modules/merge-descriptors": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz", @@ -8069,9 +8115,9 @@ } }, "node_modules/node-releases": { - "version": "2.0.18", - "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz", - "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==", + "version": "2.0.19", + "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.19.tgz", + "integrity": "sha512-xxOWJsBKtzAq7DY0J+DTzuz58K8e7sJbdgwkbMWQe8UYB6ekmsQ45q0M/tJDsGaZmbC+l7n57UV8Hl5tHxO9uw==", "dev": true }, "node_modules/normalize-path": { @@ -8096,9 +8142,9 @@ } }, "node_modules/nwsapi": { - "version": "2.2.15", - "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.15.tgz", - "integrity": "sha512-NWK6i6f70uRJgsqyNTNMQ/JbCzd8zQoFnOKdZpXqfyq0YFBQgCTFjDIXfAmkEJyV+/GzSrCCrz2iVJmJK9OX8w==", + "version": "2.2.16", + "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.16.tgz", + "integrity": "sha512-F1I/bimDpj3ncaNDhfyMWuFqmQDBwDB0Fogc2qpL3BWvkQteFD/8BzWuIRl83rq0DXfm8SGt/HFhLXZyljTXcQ==", "dev": true }, "node_modules/nyc": { @@ -8828,12 +8874,15 @@ } }, "node_modules/psl": { - "version": "1.14.0", - "resolved": "https://registry.npmjs.org/psl/-/psl-1.14.0.tgz", - "integrity": "sha512-Syk1bnf6fRZ9wQs03AtKJHcM12cKbOLo9L8JtCCdYj5/DTsHmTyXM4BK5ouWeG2P6kZ4nmFvuNTdtaqfobCOCg==", + "version": "1.15.0", + "resolved": "https://registry.npmjs.org/psl/-/psl-1.15.0.tgz", + "integrity": "sha512-JZd3gMVBAVQkSs6HdNZo9Sdo0LNcQeMNP3CozBJb3JYC/QUYZTnKxP+f8oWRX4rHP5EurWxqAHTSwUCjlNKa1w==", "dev": true, "dependencies": { "punycode": "^2.3.1" + }, + "funding": { + "url": "https://github.com/sponsors/lupomontero" } }, "node_modules/pump": { @@ -8952,18 +9001,19 @@ } }, "node_modules/reflect.getprototypeof": { - "version": "1.0.7", - "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.7.tgz", - "integrity": "sha512-bMvFGIUKlc/eSfXNX+aZ+EL95/EgZzuwA0OBPTbZZDEJw/0AkentjMuM1oiRfwHrshqk4RzdgiTg5CcDalXN5g==", + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.8.tgz", + "integrity": "sha512-B5dj6usc5dkk8uFliwjwDHM8To5/QwdKz9JcBZ8Ic4G1f0YmeeJTtE/ZTdgRFPAfxZFiUaPhZ1Jcs4qeagItGQ==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", "define-properties": "^1.2.1", + "dunder-proto": "^1.0.0", "es-abstract": "^1.23.5", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.4", - "gopd": "^1.0.1", - "which-builtin-type": "^1.1.4" + "gopd": "^1.2.0", + "which-builtin-type": "^1.2.0" }, "engines": { "node": ">= 0.4" @@ -9058,6 +9108,18 @@ "regjsparser": "bin/parser" } }, + "node_modules/regjsparser/node_modules/jsesc": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz", + "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==", + "dev": true, + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, "node_modules/release-zalgo": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/release-zalgo/-/release-zalgo-1.0.0.tgz", @@ -9170,12 +9232,12 @@ "dev": true }, "node_modules/resolve": { - "version": "1.22.8", - "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.8.tgz", - "integrity": "sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==", + "version": "1.22.9", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.9.tgz", + "integrity": "sha512-QxrmX1DzraFIi9PxdG5VkRfRwIgjwyud+z/iBwfRRrVmHc+P9Q7u2lSSpQ6bjr2gy5lrqIiU9vb6iAeGf2400A==", "dev": true, "dependencies": { - "is-core-module": "^2.13.0", + "is-core-module": "^2.16.0", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, @@ -9208,9 +9270,9 @@ } }, "node_modules/resolve.exports": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.2.tgz", - "integrity": "sha512-X2UW6Nw3n/aMgDVy+0rSqgHlv39WZAlZrXCdnbyEiKm17DSqHX4MmQMaST3FbeWR5FTuRcUwYAziZajji0Y7mg==", + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/resolve.exports/-/resolve.exports-2.0.3.tgz", + "integrity": "sha512-OcXjMsGdhL4XnbShKpAcSqPMzQoYkYyhbEaeSko47MjRP9NfEQMhZkXL1DoFlt9LWQn4YttrdnV6X2OiyzBi+A==", "dev": true, "engines": { "node": ">=10" @@ -9266,14 +9328,15 @@ } }, "node_modules/safe-array-concat": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.2.tgz", - "integrity": "sha512-vj6RsCsWBCf19jIeHEfkRMw8DPiBb+DMXklQ/1SGDHOMlHdPUkZXFQ2YdplS23zESTijAcurb1aSgJA3AgMu1Q==", + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/safe-array-concat/-/safe-array-concat-1.1.3.tgz", + "integrity": "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", - "get-intrinsic": "^1.2.4", - "has-symbols": "^1.0.3", + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "get-intrinsic": "^1.2.6", + "has-symbols": "^1.1.0", "isarray": "^2.0.5" }, "engines": { @@ -9310,14 +9373,14 @@ ] }, "node_modules/safe-regex-test": { - "version": "1.0.3", - "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.0.3.tgz", - "integrity": "sha512-CdASjNJPvRa7roO6Ra/gLYBTzYzzPyyBXxIMdGW3USQLyjWEls2RgW5UBTXaQVp+OrpeCK3bLem8smtmheoRuw==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/safe-regex-test/-/safe-regex-test-1.1.0.tgz", + "integrity": "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==", "dev": true, "dependencies": { - "call-bind": "^1.0.6", + "call-bound": "^1.0.2", "es-errors": "^1.3.0", - "is-regex": "^1.1.4" + "is-regex": "^1.2.1" }, "engines": { "node": ">= 0.4" @@ -9339,9 +9402,9 @@ "dev": true }, "node_modules/schema-utils": { - "version": "4.2.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.2.0.tgz", - "integrity": "sha512-L0jRsrPpjdckP3oPug3/VxNKt2trR8TcabrM6FOAAlvC/9Phcmm+cuAgTlxBqdBR1WJx7Naj9WHw+aOmheSVbw==", + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.3.0.tgz", + "integrity": "sha512-Gf9qqc58SpCA/xdziiHz35F4GNIWYWZrEshUc/G/r5BnLph6xpKuLeoJoQuj5WfBIx/eQLf+hmVPYHaxJu7V2g==", "dev": true, "dependencies": { "@types/json-schema": "^7.0.9", @@ -9350,7 +9413,7 @@ "ajv-keywords": "^5.1.0" }, "engines": { - "node": ">= 12.13.0" + "node": ">= 10.13.0" }, "funding": { "type": "opencollective", @@ -9481,15 +9544,69 @@ } }, "node_modules/side-channel": { - "version": "1.0.6", - "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz", - "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz", + "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", "es-errors": "^1.3.0", - "get-intrinsic": "^1.2.4", - "object-inspect": "^1.13.1" + "object-inspect": "^1.13.3", + "side-channel-list": "^1.0.0", + "side-channel-map": "^1.0.1", + "side-channel-weakmap": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz", + "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==", + "dev": true, + "dependencies": { + "es-errors": "^1.3.0", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-map": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz", + "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==", + "dev": true, + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/side-channel-weakmap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz", + "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==", + "dev": true, + "dependencies": { + "call-bound": "^1.0.2", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.5", + "object-inspect": "^1.13.3", + "side-channel-map": "^1.0.1" }, "engines": { "node": ">= 0.4" @@ -9711,15 +9828,18 @@ } }, "node_modules/string.prototype.trim": { - "version": "1.2.9", - "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.9.tgz", - "integrity": "sha512-klHuCNxiMZ8MlsOihJhJEBJAiMVqU3Z2nEXWfWnIqjN0gEFS9J9+IxKozWWtQGcgoa1WUZzLjKPTr4ZHNFTFxw==", + "version": "1.2.10", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.10.tgz", + "integrity": "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", + "define-data-property": "^1.1.4", "define-properties": "^1.2.1", - "es-abstract": "^1.23.0", - "es-object-atoms": "^1.0.0" + "es-abstract": "^1.23.5", + "es-object-atoms": "^1.0.0", + "has-property-descriptors": "^1.0.2" }, "engines": { "node": ">= 0.4" @@ -9729,15 +9849,19 @@ } }, "node_modules/string.prototype.trimend": { - "version": "1.0.8", - "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.8.tgz", - "integrity": "sha512-p73uL5VCHCO2BZZ6krwwQE3kCzM7NKmis8S//xEC6fQonchbum4eP6kR4DLEjQFO3Wnj3Fuo8NM0kOSjVdHjZQ==", + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.9.tgz", + "integrity": "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", + "call-bound": "^1.0.2", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" }, + "engines": { + "node": ">= 0.4" + }, "funding": { "url": "https://github.com/sponsors/ljharb" } @@ -9841,9 +9965,9 @@ } }, "node_modules/terser": { - "version": "5.36.0", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.36.0.tgz", - "integrity": "sha512-IYV9eNMuFAV4THUspIRXkLakHnV6XO7FEdtKjf/mDyrnqUg9LnlOn6/RwRvM9SZjR4GUq8Nk8zj67FzVARr74w==", + "version": "5.37.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.37.0.tgz", + "integrity": "sha512-B8wRRkmre4ERucLM/uXx4MOV5cbnOlVAqUst+1+iLKPI0dOgFO28f84ptoQt9HEI537PMzfYa/d+GEPKTRXmYA==", "dev": true, "dependencies": { "@jridgewell/source-map": "^0.3.3", @@ -9859,16 +9983,16 @@ } }, "node_modules/terser-webpack-plugin": { - "version": "5.3.10", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.10.tgz", - "integrity": "sha512-BKFPWlPDndPs+NGGCr1U59t0XScL5317Y0UReNrHaw9/FwhPENlq6bfgs+4yPfyP51vqC1bQ4rp1EfXW5ZSH9w==", + "version": "5.3.11", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.3.11.tgz", + "integrity": "sha512-RVCsMfuD0+cTt3EwX8hSl2Ks56EbFHWmhluwcqoPKtBnfjiT6olaq7PRIRfhyU8nnC2MrnDrBLfrD/RGE+cVXQ==", "dev": true, "dependencies": { - "@jridgewell/trace-mapping": "^0.3.20", + "@jridgewell/trace-mapping": "^0.3.25", "jest-worker": "^27.4.5", - "schema-utils": "^3.1.1", - "serialize-javascript": "^6.0.1", - "terser": "^5.26.0" + "schema-utils": "^4.3.0", + "serialize-javascript": "^6.0.2", + "terser": "^5.31.1" }, "engines": { "node": ">= 10.13.0" @@ -9906,24 +10030,6 @@ "node": ">= 10.13.0" } }, - "node_modules/terser-webpack-plugin/node_modules/schema-utils": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", - "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", - "dev": true, - "dependencies": { - "@types/json-schema": "^7.0.8", - "ajv": "^6.12.5", - "ajv-keywords": "^3.5.2" - }, - "engines": { - "node": ">= 10.13.0" - }, - "funding": { - "type": "opencollective", - "url": "https://opencollective.com/webpack" - } - }, "node_modules/terser-webpack-plugin/node_modules/supports-color": { "version": "8.1.1", "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", @@ -10129,16 +10235,16 @@ } }, "node_modules/typed-array-byte-length": { - "version": "1.0.1", - "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.1.tgz", - "integrity": "sha512-3iMJ9q0ao7WE9tWcaYKIptkNBuOIcZCCT0d4MRvuuH88fEoEH62IuQe0OtraD3ebQEoTRk8XCBoknUNc1Y67pw==", + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/typed-array-byte-length/-/typed-array-byte-length-1.0.2.tgz", + "integrity": "sha512-adiFrvWBKqevPpbl+LErGnoS7juikX0VLSK+s4rcUEqAv2gClx0DB/g0gMUQXMZiG2RhUDUFgQpyXta4AKG9VA==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", + "call-bind": "^1.0.8", "for-each": "^0.3.3", - "gopd": "^1.0.1", - "has-proto": "^1.0.3", - "is-typed-array": "^1.1.13" + "gopd": "^1.2.0", + "has-proto": "^1.2.0", + "is-typed-array": "^1.1.14" }, "engines": { "node": ">= 0.4" @@ -10211,15 +10317,18 @@ } }, "node_modules/unbox-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.2.tgz", - "integrity": "sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==", + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz", + "integrity": "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw==", "dev": true, "dependencies": { - "call-bind": "^1.0.2", + "call-bound": "^1.0.3", "has-bigints": "^1.0.2", - "has-symbols": "^1.0.3", - "which-boxed-primitive": "^1.0.2" + "has-symbols": "^1.1.0", + "which-boxed-primitive": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" @@ -10392,16 +10501,16 @@ "dev": true }, "node_modules/webpack": { - "version": "5.96.1", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.96.1.tgz", - "integrity": "sha512-l2LlBSvVZGhL4ZrPwyr8+37AunkcYj5qh8o6u2/2rzoPc8gxFJkLj1WxNgooi9pnoc06jh0BjuXnamM4qlujZA==", + "version": "5.97.1", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.97.1.tgz", + "integrity": "sha512-EksG6gFY3L1eFMROS/7Wzgrii5mBAFe4rIr3r2BTfo7bcc+DWwFZ4OJ/miOuHJO/A85HwyI4eQ0F6IKXesO7Fg==", "dev": true, "dependencies": { "@types/eslint-scope": "^3.7.7", "@types/estree": "^1.0.6", - "@webassemblyjs/ast": "^1.12.1", - "@webassemblyjs/wasm-edit": "^1.12.1", - "@webassemblyjs/wasm-parser": "^1.12.1", + "@webassemblyjs/ast": "^1.14.1", + "@webassemblyjs/wasm-edit": "^1.14.1", + "@webassemblyjs/wasm-parser": "^1.14.1", "acorn": "^8.14.0", "browserslist": "^4.24.0", "chrome-trace-event": "^1.0.2", @@ -10583,40 +10692,43 @@ } }, "node_modules/which-boxed-primitive": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz", - "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.1.1.tgz", + "integrity": "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA==", "dev": true, "dependencies": { - "is-bigint": "^1.0.1", - "is-boolean-object": "^1.1.0", - "is-number-object": "^1.0.4", - "is-string": "^1.0.5", - "is-symbol": "^1.0.3" + "is-bigint": "^1.1.0", + "is-boolean-object": "^1.2.1", + "is-number-object": "^1.1.1", + "is-string": "^1.1.1", + "is-symbol": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" }, "funding": { "url": "https://github.com/sponsors/ljharb" } }, "node_modules/which-builtin-type": { - "version": "1.2.0", - "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.0.tgz", - "integrity": "sha512-I+qLGQ/vucCby4tf5HsLmGueEla4ZhwTBSqaooS+Y0BuxN4Cp+okmGuV+8mXZ84KDI9BA+oklo+RzKg0ONdSUA==", + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/which-builtin-type/-/which-builtin-type-1.2.1.tgz", + "integrity": "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q==", "dev": true, "dependencies": { - "call-bind": "^1.0.7", + "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", - "is-date-object": "^1.0.5", + "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", - "is-regex": "^1.1.4", + "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", - "which-boxed-primitive": "^1.0.2", + "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", - "which-typed-array": "^1.1.15" + "which-typed-array": "^1.1.16" }, "engines": { "node": ">= 0.4" diff --git a/package.json b/package.json index 7331845..e33c76c 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "amazon-connect-streams", - "version": "2.17.0", + "version": "2.18.0", "description": "Amazon Connect Streams Library", "engines": { "node": ">=12.0.0" diff --git a/release/connect-streams-dr-min.js b/release/connect-streams-dr-min.js index d220d7e..d52fe13 100644 --- a/release/connect-streams-dr-min.js +++ b/release/connect-streams-dr-min.js @@ -1 +1 @@ -(()=>{var l;(l={296:()=>{!function(){var l=this||globalThis,Z=l.connect||{};l.connect=Z,l.globalConnect={},l.lily=Z,globalConnect.Container=null;var b=window.atob("(()=>{var e={781:(e,t,n)=>{"use strict";let r;function o(e){if(!r)throw new Error(null!=e?e:"Attempted to get Global AmazonConnectProvider that has not been set.");return r}function i(){return"randomUUID"in crypto?crypto.randomUUID():"10000000-1000-4000-8000-100000000000".replace(/[018]/g,(e=>{const t=parseInt(e);return(t^crypto.getRandomValues(new Uint8Array(1))[0]&15>>t/4).toString(16)}))}n.r(t),n.d(t,{AmazonConnectStreamsSite:()=>_});class a{constructor(){this.idsByHandler=new Map,this.handlersById=new Map}add(e){const t=this.idsByHandler.get(e);if(t)return{handlerId:t};const n=i();return this.idsByHandler.set(e,n),this.handlersById.set(n,e),{handlerId:n}}getIdByHandler(e){var t;return null!==(t=this.idsByHandler.get(e))&&void 0!==t?t:null}getHandlerById(e){var t;return null!==(t=this.handlersById.get(e))&&void 0!==t?t:null}get(){return[...this.idsByHandler.entries()].map((([e,t])=>({handler:e,handlerId:t})))}delete(e){const t=this.idsByHandler.get(e);return t&&this.handlersById.delete(t),this.idsByHandler.delete(e),{isEmpty:this.idsByHandler.size<1}}size(){return this.idsByHandler.size}}class s{constructor(){this.simpleSubscriptions=new Map,this.paramSubscriptions=new Map}add({namespace:e,key:t,parameter:n},r){var o,i,a,s,c;if(n){if(!this.paramSubscriptions.has(e))return void this.paramSubscriptions.set(e,new Map([[t,new Map([[n,r]])]]));if(!(null===(o=this.paramSubscriptions.get(e))||void 0===o?void 0:o.has(t)))return void(null===(i=this.paramSubscriptions.get(e))||void 0===i||i.set(t,new Map([[n,r]])));null===(s=null===(a=this.paramSubscriptions.get(e))||void 0===a?void 0:a.get(t))||void 0===s||s.set(n,r)}else{if(!this.simpleSubscriptions.has(e))return void this.simpleSubscriptions.set(e,new Map([[t,r]]));null===(c=this.simpleSubscriptions.get(e))||void 0===c||c.set(t,r)}}delete({namespace:e,key:t,parameter:n}){var r,o,i,a;n?(null===(o=null===(r=this.paramSubscriptions.get(e))||void 0===r?void 0:r.get(t))||void 0===o?void 0:o.delete(n))&&this.paramSubscriptions.get(e).get(t).size<1&&(null===(i=this.paramSubscriptions.get(e))||void 0===i||i.delete(t),this.paramSubscriptions.get(e).size<1&&this.paramSubscriptions.delete(e)):(null===(a=this.simpleSubscriptions.get(e))||void 0===a?void 0:a.delete(t))&&this.simpleSubscriptions.get(e).size<1&&this.simpleSubscriptions.delete(e)}get({namespace:e,key:t,parameter:n}){var r,o,i;return n?null===(i=null===(o=this.paramSubscriptions.get(e))||void 0===o?void 0:o.get(t))||void 0===i?void 0:i.get(n):null===(r=this.simpleSubscriptions.get(e))||void 0===r?void 0:r.get(t)}getOrAdd(e,t){let n=this.get(e);return n||(n=t(),this.add(e,n)),n}addOrUpdate(e,t,n){let r=this.get(e);return r=r?n(r):t(),this.add(e,r),r}getAllSubscriptions(){return[...Array.from(this.simpleSubscriptions.keys()).flatMap((e=>Array.from(this.simpleSubscriptions.get(e).keys()).flatMap((t=>({namespace:e,key:t}))))),...Array.from(this.paramSubscriptions.keys()).flatMap((e=>Array.from(this.paramSubscriptions.get(e).keys()).flatMap((t=>Array.from(this.paramSubscriptions.get(e).get(t).keys()).flatMap((n=>({namespace:e,key:t,parameter:n})))))))]}}class c{constructor(){this.subscriptions=new s}add(e,t){return this.subscriptions.getOrAdd(e,(()=>new a)).add(t)}get(e){var t,n;return null!==(n=null===(t=this.subscriptions.get(e))||void 0===t?void 0:t.get())&&void 0!==n?n:[]}getById(e,t){var n,r;return null!==(r=null===(n=this.subscriptions.get(e))||void 0===n?void 0:n.getHandlerById(t))&&void 0!==r?r:null}delete(e,t){var n,r;null!==(r=null===(n=this.subscriptions.get(e))||void 0===n?void 0:n.delete(t).isEmpty)&&void 0!==r&&r&&this.subscriptions.delete(e)}size(e){var t,n;return null!==(n=null===(t=this.subscriptions.get(e))||void 0===t?void 0:t.size())&&void 0!==n?n:0}isEmpty(e){return 0===this.size(e)}getAllSubscriptions(){return this.subscriptions.getAllSubscriptions()}getAllSubscriptionHandlerIds(){return this.subscriptions.getAllSubscriptions().reduce(((e,t)=>e.concat(this.get(t).map((({handlerId:e})=>({topic:t,handlerId:e}))))),[])}}class u extends Error{constructor({reason:e,namespace:t,errorKey:n,details:r}){super(`ConnectError with error key "${n}"`),this.errorType=u.ErrorType,this.namespace=t,this.errorKey=n,this.reason=e,this.details=null!=r?r:{}}}u.ErrorType="ConnectError";const l="clientTimeout";function p(e,t,n,r){const o=Math.max(1,null!=r?r:3e4);return new Promise(((r,i)=>{let a=!1;const s=setTimeout((()=>{n({timeoutMs:o,request:e}),i(function(e,t){const{namespace:n,command:r,data:o}=e;return{namespace:n,reason:"Client Timeout",details:{command:r,requestData:o,timeoutMs:t},errorKey:l}}(e,o)),a=!0}),o);t((e=>{clearTimeout(s),a||(e.isError?i(new u(e)):r(e.data))}))}))}class d{constructor(e){this.requestMap=new Map,this.logger=new I({provider:e,source:"core.requestManager"})}processRequest(e){const{requestId:t}=e;return p(e,(e=>this.requestMap.set(t,e)),(({request:e,timeoutMs:t})=>this.handleTimeout(e,t)))}processResponse(e){const{requestId:t}=e,n=this.requestMap.get(t);n?(n(e),this.requestMap.delete(t)):this.logger.error("Returned a response message with no handler",{message:e})}handleTimeout(e,t){const{requestId:n,namespace:r,command:o}=e;this.requestMap.delete(n),this.logger.error("Client request timeout",{requestId:n,namespace:r,command:o,timeoutMs:t})}}var f=function(e,t){var n={};for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&t.indexOf(r)<0&&(n[r]=e[r]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(r=Object.getOwnPropertySymbols(e);o<r.length;o++)t.indexOf(r[o])<0&&Object.prototype.propertyIsEnumerable.call(e,r[o])&&(n[r[o]]=e[r[o]])}return n};function h(e){try{switch(e.type){case"acknowledge":case"error":case"childConnectionClose":default:return e;case"childDownstreamMessage":return Object.assign(Object.assign({},e),{message:h(e.message)});case"publish":{const{data:t}=e,n=f(e,["data"]);return Object.assign({},n)}case"response":if(e.isError)return Object.assign(Object.assign({},e),{details:{command:e.details.command}});{const{data:t}=e,n=f(e,["data"]);return Object.assign({},n)}}}catch(t){return{messageDetails:"error when sanitizing downstream message",message:e,error:t}}}class g{constructor(e,t){this.provider=e,this.relayChildUpstreamMessage=t,this.messagePorts=new Map,this.logger=new I({provider:e,source:"childConnectionManager"})}addChannel({connectionId:e,port:t,providerId:n}){if(this.messagePorts.has(e))return void this.logger.error("Attempted to add child connection that already exists. No action",{connectionId:e});const r=this.createMessageHandler(e,n);t.addEventListener("message",r),t.start(),this.messagePorts.set(e,{port:t,handler:r,providerId:n}),this.relayChildUpstreamMessage({type:"childUpstream",connectionId:e,sourceProviderId:n,parentProviderId:this.provider.id,message:{type:"childConnectionReady"}}),this.logger.debug("Child port added",{connectionId:e})}handleDownstreamMessage({connectionId:e,message:t,targetProviderId:n}){const r=this.messagePorts.get(e);if(!r)return void this.logger.warn("Attempted to route downstream message to child message port that does not exist",{connectionId:e,message:h(t)});const{port:o,providerId:i}=r;i&&i!==n?this.logger.error("Downstream target message did not match target provider id. Not sending message.",{connectionId:e,targetProviderId:n,actualProviderId:i,message:h(t)}):o.postMessage(t)}handleCloseMessage({connectionId:e}){const t=this.messagePorts.get(e);if(!t)return void this.logger.warn("Attempted to close child message port that was not found",{connectionId:e});const{port:n,handler:r}=t;n.removeEventListener("message",r),n.close(),this.messagePorts.delete(e),this.logger.debug("Removed child message channel",{connectionId:e})}createMessageHandler(e,t){return n=>this.relayChildUpstreamMessage({type:"childUpstream",sourceProviderId:t,parentProviderId:this.provider.id,connectionId:e,message:n.data})}}class m{constructor(e){this.errorHandlers=new Set,this.logger=new I({provider:e,source:"core.proxy.error"})}invoke(e){const{message:t,key:n,details:r,isFatal:o,connectionStatus:i}=e;this.logger.error(t,{key:n,details:r,isFatal:o,connectionStatus:i},{duplicateMessageToConsole:!0,remoteIgnore:!0}),[...this.errorHandlers].forEach((t=>{try{t(e)}catch(t){this.logger.error("An error occurred within a AmazonConnectErrorHandler",{handlerError:t,originalError:e})}}))}onError(e){this.errorHandlers.add(e)}offError(e){this.errorHandlers.delete(e)}}class v{constructor(e){this.status="notConnected",this.changeHandlers=new Set,this.logger=new I({source:"core.proxy.connection-status-manager",provider:e,mixin:()=>({status:this.status})})}getStatus(){return this.status}update(e){this.status=e.status,this.logger.trace("Proxy Connection Status Changed",{status:e.status}),[...this.changeHandlers].forEach((t=>{try{t(e)}catch(e){this.logger.error("An error occurred within a ProxyConnectionChangedHandler",{error:e})}}))}onChange(e){this.changeHandlers.add(e)}offChange(e){this.changeHandlers.delete(e)}}var y,b=function(e,t,n,r){return new(n||(n=Promise))((function(o,i){function a(e){try{c(r.next(e))}catch(e){i(e)}}function s(e){try{c(r.throw(e))}catch(e){i(e)}}function c(e){var t;e.done?o(e.value):(t=e.value,t instanceof n?t:new n((function(e){e(t)}))).then(a,s)}c((r=r.apply(e,t||[])).next())}))},E=function(e,t){var n={};for(var r in e)Object.prototype.hasOwnProperty.call(e,r)&&t.indexOf(r)<0&&(n[r]=e[r]);if(null!=e&&"function"==typeof Object.getOwnPropertySymbols){var o=0;for(r=Object.getOwnPropertySymbols(e);o<r.length;o++)t.indexOf(r[o])<0&&Object.prototype.propertyIsEnumerable.call(e,r[o])&&(n[r[o]]=e[r[o]])}return n};class S{constructor(e){this.provider=e,this.logger=new I({source:"core.proxy",provider:e,mixin:()=>({proxyType:this.proxyType,connectionId:this.connectionId})}),this.requestManager=new d(e),this.status=new v(e),this.errorService=new m(e),this.upstreamMessageQueue=[],this.connectionEstablished=!1,this.isInitialized=!1,this.subscriptions=new c,this.connectionId=null,this.channelManager=new g(e,this.sendOrQueueMessageToSubject.bind(this))}init(){if(this.isInitialized)throw new Error("Proxy already initialized");this.isInitialized=!0,this.initProxy()}request(e,t,n,r){const o=function(e,t,n,r){return{type:"request",namespace:e,command:t,requestId:i(),data:n,messageOrigin:r}}(e,t,n,null!=r?r:this.getUpstreamMessageOrigin()),a=this.requestManager.processRequest(o);return this.sendOrQueueMessageToSubject(o),a}subscribe(e,t,n){const{handlerId:r}=this.subscriptions.add(e,t),o={type:"subscribe",topic:e,messageOrigin:null!=n?n:this.getUpstreamMessageOrigin(),handlerId:r};this.sendOrQueueMessageToSubject(o)}unsubscribe(e,t,n){if(this.subscriptions.delete(e,t),this.subscriptions.isEmpty(e)){const t={type:"unsubscribe",topic:e,messageOrigin:null!=n?n:this.getUpstreamMessageOrigin()};this.sendOrQueueMessageToSubject(t)}}log(e){const t=function({level:e,source:t,message:n,loggerId:r,data:o},i,a){const s=o?JSON.parse(JSON.stringify(o)):void 0;return{type:"log",level:e,time:new Date,source:t,message:n,loggerId:r,data:s,context:i,messageOrigin:a}}(e,this.addContextToLogger(),this.getUpstreamMessageOrigin());this.sendOrQueueMessageToSubject(t)}sendLogMessage(e){"log"===e.type?(e.context=Object.assign(Object.assign({},e.context),this.addContextToLogger()),this.sendOrQueueMessageToSubject(e)):this.logger.error("Attempted to send invalid log message",{message:e})}sendMetric({metricData:e,time:t,namespace:n}){const r=function({metricData:e,time:t,namespace:n},r){var o,i;return{type:"metric",namespace:n,metricName:e.metricName,unit:e.unit,value:e.value,time:t,dimensions:null!==(o=e.dimensions)&&void 0!==o?o:{},optionalDimensions:null!==(i=e.optionalDimensions)&&void 0!==i?i:{},messageOrigin:r}}({metricData:e,time:t,namespace:n},this.getUpstreamMessageOrigin());this.sendOrQueueMessageToSubject(r)}sendMetricMessage(e){"metric"===e.type?this.sendOrQueueMessageToSubject(e):this.logger.error("Attempted to send invalid metric message",{metricMessage:e})}sendOrQueueMessageToSubject(e){this.connectionEstablished?this.sendMessageToSubject(e):this.upstreamMessageQueue.push(e)}consumerMessageHandler(e){if(!this.isInitialized)return void this.logger.error("Attempted to process message from subject prior to proxy being initializing. Message not processed",{originalMessageEventData:e.data});const{data:t}=e;if(!("type"in t))return void this.logger.warn("Unknown inbound message",{originalMessageEventData:t});const n=t;this.handleMessageFromSubject(n)}handleMessageFromSubject(e){this.handleDefaultMessageFromSubject(e)}handleDefaultMessageFromSubject(e){switch(e.type){case"acknowledge":this.handleConnectionAcknowledge(e);break;case"response":this.handleResponse(e);break;case"publish":this.handlePublish(e);break;case"error":this.handleError(e);break;case"childDownstreamMessage":this.channelManager.handleDownstreamMessage(e);break;case"childConnectionClose":this.channelManager.handleCloseMessage(e);break;default:return void this.logger.error("Unknown inbound message",{originalMessageEventData:e})}}handleConnectionAcknowledge(e){for(this.connectionId=e.connectionId,this.status.update({status:"ready",connectionId:e.connectionId}),this.connectionEstablished=!0;this.upstreamMessageQueue.length;){const e=this.upstreamMessageQueue.shift();this.sendMessageToSubject(e)}}handleResponse(e){this.requestManager.processResponse(e)}handlePublish(e){const{handlerId:t,topic:n}=e;if(t){const r=this.subscriptions.getById(n,t);r&&this.handleAsyncSubscriptionHandlerInvoke({handler:r,handlerId:t},e)}else this.subscriptions.get(n).map((t=>{this.handleAsyncSubscriptionHandlerInvoke(t,e)}))}handleError(e){if(e.isFatal){const{message:t,type:n}=e,r=E(e,["message","type"]);this.status.update({status:"error",reason:t,details:r})}this.publishError({message:e.message,key:e.key,details:e.details,isFatal:e.isFatal,proxyStatus:e.status})}publishError(e){const t=Object.assign(Object.assign({},e),{connectionStatus:this.connectionStatus});this.errorService.invoke(t)}handleAsyncSubscriptionHandlerInvoke(e,t){return b(this,arguments,void 0,(function*({handler:e,handlerId:t},{topic:n,data:r}){try{yield e(r)}catch(e){this.logger.error("An error occurred when handling subscription",{topic:n,error:e,handlerId:t})}}))}get connectionStatus(){return this.status.getStatus()}onError(e){this.errorService.onError(e)}offError(e){this.errorService.offError(e)}onConnectionStatusChange(e){this.status.onChange(e)}offConnectionStatusChange(e){this.status.offChange(e)}addChildChannel(e){this.channelManager.addChannel(e)}resetConnection(e){var t;this.connectionEstablished=!1,this.status.update({status:"reset",reason:e});const n=this.subscriptions.getAllSubscriptionHandlerIds();this.logger.info("Resetting proxy",{reason:e,subscriptionHandlerCount:null!==(t=null==n?void 0:n.length)&&void 0!==t?t:-1}),null==n||n.map((({topic:e,handlerId:t})=>({type:"subscribe",topic:e,messageOrigin:this.getUpstreamMessageOrigin(),handlerId:t}))).forEach((e=>this.sendOrQueueMessageToSubject(e)))}}class C{constructor({config:e,proxyFactory:t}){if(this._id=i(),!t)throw new Error("Attempted to get Proxy before setting up factory");if(!e)throw new Error("Failed to include config");this.proxyFactory=t,this._config=e}get id(){return this._id}getProxy(){return this.proxy||(this.proxy=this.proxyFactory(this),this.proxy.init()),this.proxy}get config(){return Object.assign({},this._config)}onError(e){this.getProxy().onError(e)}offError(e){this.getProxy().offError(e)}static initializeProvider(e){const t=new I({source:"core.amazonConnect.init",provider:e});if(this.isInitialized){const e="Error: Attempted to initialize provider more than one time.";throw t.error(e),new Error(e)}return function(e){if(r)throw new Error("Global Provider is already set");r=e}(e),this.isInitialized=!0,e.getProxy(),e}}C.isInitialized=!1,function(e){e[e.trace=1]="trace",e[e.debug=2]="debug",e[e.info=3]="info",e[e.warn=4]="warn",e[e.error=5]="error"}(y||(y={}));class T{constructor(e){this.mixin=e}getTransformedData(e,t){return this.mixin?Object.assign(Object.assign({},null!=t?t:{}),this.mixin(null!=t?t:{},e)):t}}class I{constructor(e){this._proxy=null,this._logToConsoleLevel=null,this.loggerId=function(e){const t=new Uint8Array(Math.ceil(e/2));return crypto.getRandomValues(t),Array.from(t,(e=>e.toString(16).padStart(2,"0"))).join("").substring(0,e)}(8),"string"==typeof e?(this.source=e,this.dataTransformer=new T(void 0)):(this.source=e.source,e.provider&&"function"==typeof e.provider?this.providerFactory=e.provider:this.provider=e.provider,this.dataTransformer=new T(e.mixin),this.logOptions=e.options)}trace(e,t,n){this.log(y.trace,e,t,n)}debug(e,t,n){this.log(y.debug,e,t,n)}info(e,t,n){this.log(y.info,e,t,n)}warn(e,t,n){this.log(y.warn,e,t,n)}error(e,t,n){this.log(y.error,e,t,n)}log(e,t,n,r){const o=this.dataTransformer.getTransformedData(e,n);this.ignoreRemote(r)||this.getProxy().log({level:e,source:this.source,loggerId:this.loggerId,message:t,data:o}),this.applyDuplicateMessageToConsole(e,r)&&function(e,t,n){if(n)switch(e){case y.error:console.error(t,n);break;case y.warn:console.warn(t,n);break;case y.info:console.info(t,n);break;case y.debug:console.debug(t,n);break;case y.trace:console.trace(t,n);break;default:console.log(t,n)}else switch(e){case y.error:console.error(t);break;case y.warn:console.warn(t);break;case y.info:console.info(t);break;case y.debug:console.debug(t);break;case y.trace:console.trace(t);break;default:console.log(t)}}(e,t,o)}getProvider(){return this.provider||(this.provider=this.providerFactory?this.providerFactory():o()),this.provider}getProxy(){return this._proxy||(this._proxy=this.getProvider().getProxy()),this._proxy}applyDuplicateMessageToConsole(e,t){return(null==t?void 0:t.duplicateMessageToConsole)||this.getLogConsoleLevel()<=e}getLogConsoleLevel(){var e,t,n,r;return this._logToConsoleLevel||(this._logToConsoleLevel=(null===(e=this.logOptions)||void 0===e?void 0:e.minLogToConsoleLevelOverride)?this.logOptions.minLogToConsoleLevelOverride:null!==(r=null===(n=null===(t=this.getProvider().config)||void 0===t?void 0:t.logging)||void 0===n?void 0:n.minLogToConsoleLevel)&&void 0!==r?r:y.error),this._logToConsoleLevel}ignoreRemote(e){var t,n,r;return null!==(n=null===(t=this.logOptions)||void 0===t?void 0:t.remoteIgnore)&&void 0!==n&&n||null!==(r=null==e?void 0:e.remoteIgnore)&&void 0!==r&&r}}class w extends S{constructor(e){super(e),this.postMessageHandler=this.listenForInitialMessage.bind(this),this.proxyLogger=new I({source:"siteProxy",provider:e})}initProxy(){this.status.update({status:"connecting"}),window.addEventListener("message",this.postMessageHandler)}resetConnection(e){super.resetConnection(e),this.messagePort=void 0,this.status.update({status:"connecting"})}sendMessageToSubject(e){this.messagePort?this.messagePort.postMessage(e):this.proxyLogger.error("Failed to send UpstreamMessage. MessagePort not set",{messageType:e.type})}addContextToLogger(){return{}}listenForInitialMessage(e){if(this.verifyEventSource(e)){if(!this.verifyOrigin(e))return;if("cross-domain-adapter-init"!==e.data.type)return void this.invalidInitMessageHandler(e.data);if(this.messagePort&&(this.resetConnection("Subsequent Message Port Detected"),this.proxyLogger.info("Subsequent message port received. Resetting connection")),this.messagePort=e.ports[0],!this.messagePort)throw new Error("message port not provided by iframe");this.messagePort.onmessage=this.consumerMessageHandler.bind(this),this.status.update({status:"initializing"}),this.messagePort.postMessage({type:"cross-domain-site-ready",providerId:this.provider.id}),this.proxyLogger.debug("CDA Post message handler removed")}}verifyOrigin(e){const t=e.origin;if(!t)return this.proxyLogger.warn("No origin provided in event. Ignoring event."),!1;let n;try{n=new URL(this.provider.config.instanceUrl).origin}catch(e){return this.proxyLogger.error("Unable to parse expected origin from config. Cannot match",{error:e,eventOrigin:t,configInstanceUrl:this.provider.config.instanceUrl},{duplicateMessageToConsole:!0}),!1}return t===n||("cross-domain-adapter-init"===e.data.type&&this.proxyLogger.warn("Origin of message with type 'cross-domain-adapter-init' did not expected instance value. Ignoring",{expectedOrigin:n,eventOrigin:t},{duplicateMessageToConsole:!0}),!1)}}class A extends w{constructor(e){super(e),this.ccpIFrame=null}get proxyType(){return"streams-site"}setCCPIframe(e){const t=Boolean(this.ccpIFrame);this.ccpIFrame=e,t&&this.resetConnection("CCP IFrame Updated")}getUpstreamMessageOrigin(){return Object.assign({_type:"streams-site",providerId:this.provider.id},{origin:null!==(t=null===(e=null===document||void 0===document?void 0:document.location)||void 0===e?void 0:e.origin)&&void 0!==t?t:"unknown",path:null!==(r=null===(n=null===document||void 0===document?void 0:document.location)||void 0===n?void 0:n.pathname)&&void 0!==r?r:"unknown"});var e,t,n,r}verifyEventSource(e){const t=this.ccpIFrame;if(!t)return this.proxyLogger.error("CCP Iframe not provided to proxy. Unable to verify event to Connect to CCP.",{origin:e.origin}),!1;const n=e.source===t.contentWindow;return n||this.proxyLogger.warn("Message came from unexpected iframe. Not a valid CCP. Will not connect",{origin:e.origin}),n}invalidInitMessageHandler(){}}class _ extends C{constructor(e){super({config:e,proxyFactory:e=>new A(e)})}static init(e){const t=new _(e);return _.initializeProvider(t),{provider:t}}static get default(){return o("AmazonConnectStreamsSite has not been initialized")}setCCPIframe(e){this.getProxy().setCCPIframe(e)}}},825:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t,t.agentApp={};var n={CCP:"ccp",GUIDES:"customviews"};t.agentApp.initCCP=t.core.initCCP,t.agentApp.isInitialized=function(e){},t.agentApp.initAppCommunication=function(e,n){var r=document.getElementById(e),o=new t.IFrameConduit(n,window,r),i=[t.AgentEvents.UPDATE,t.ContactEvents.VIEW,t.EventType.ACKNOWLEDGE,t.EventType.TERMINATED,t.TaskEvents.CREATED,t.EmailEvents.CREATED];r.addEventListener("load",(function(e){i.forEach((function(e){t.core.getUpstream().onUpstream(e,(function(t){o.sendUpstream(e,t)}))}))}))};var r=function(e){var t=e.indexOf("ccp-v2");return e.slice(0,t-1)},o=function(e){if("string"==typeof e)return e;try{return e.getContactId()}catch(t){return void console.error("[CustomViews]: Invalid Contact Provided: ",e)}};t.agentApp.initApp=function(e,i,a,s){s=s||{};var c,u=a.endsWith("/")||/[?&]?[^=?&]+=[^=?&]+/g.test(a)?a:a+"/",l=s.onLoad?s.onLoad:null,p={endpoint:u,style:s.style,onLoad:l};if(e===n.CCP_DR)c=n.CCP;else if(e===n.GUIDES&&s.customViewsParams){var d=s.customViewsParams.iframeSuffix;if(c=d?"".concat(n.GUIDES).concat(d):"".concat(n.GUIDES),void 0!==t.agentApp.AppRegistry.get(c))throw new Error("[CustomViews]: Custom views application with the same name already exists. Please provide a different iframeSuffix for the custom views application.")}else c=e;var f="string"==typeof i?document.getElementById(i):i;t.agentApp.AppRegistry.register(c,p,f),t.agentApp.AppRegistry.start(c,(function(i){var a=i.endpoint,u=i.containerDOM;return{init:function(){switch(e){case n.CCP:return s.ccpParams=s.ccpParams?s.ccpParams:{},s.style&&(s.ccpParams.style=s.style),function(e,n,o){var i={ccpUrl:e,ccpLoadTimeout:1e4,loginPopup:!0,loginUrl:r(e)+"/login",softphone:{allowFramedSoftphone:!0,disableRingtone:!1,allowFramedVideoCall:!0,allowFramedScreenSharing:!0,allowFramedScreenSharingPopUp:!1}},a=t.merge(i,o.ccpParams);t.core.initCCP(n,a)}(a,u,s);case n.GUIDES:return void 0!==s.customViewsParams?(t.agentApp.initAppCommunication(c,a,u),function(e,r,i){var a,s,c=i.customViewsParams,u=c.contact,l=c.disableAutoDestroy,p=c.iframeSuffix,d=c.terminateCustomViewOptions,f=void 0===d?{}:d,h=i.customViewsParams.contactFlowId;void 0!==u&&((a=o(u))&&!0!==l&&"string"!=typeof u&&u.onDestroy((function(n){t.core.terminateCustomView(e,p,{timeout:f.timeout||5e3,hideIframe:void 0===f.hideIframe||f.hideIframe,resolveIframe:void 0===f.resolveIframe||f.resolveIframe})})),h||console.warn("[CustomViews]: Need to provide a contactFlowId when defining contact parameter for initalizing customviews application")),s=p?"".concat(n.GUIDES).concat(p):"".concat(n.GUIDES);var g="iframe[id='".concat(s,"']"),m=(null==r?void 0:r.querySelector(g))||document.getElementById(s)||window.top.document.getElementById(s);if(!m)throw new Error("[CustomViews]: No iframe found for the app: ",s);var v=AWS.util.uuid.v4();a?m.src="".concat(e,"?contactFlowId=").concat(h,"&currentContactId=").concat(a,"&agentAppTabId=").concat(v,"-tab"):h&&(m.src="".concat(e,"?contactFlowId=").concat(h,"&agentAppTabId=").concat(v,"-tab"))}(a,u,s)):t.agentApp.initAppCommunication(c,a,u);default:return t.agentApp.initAppCommunication(c,a,u)}},destroy:function(){switch(e){case n.CCP:return i=r(a)+"/logout",t.fetch(i,{credentials:"include"}).then((function(){return t.core.getEventBus().trigger(t.EventType.TERMINATE),!0})).catch((function(e){return t.getLog().error("An error occured on logout."+e).withException(e),window.location.href=i,!1}));case n.GUIDES:return void 0!==s.customViewsParams?(o=c,void t.agentApp.AppRegistry.delete(o)):null;default:return null}var o,i}}}))},t.agentApp.stopApp=function(e){return t.agentApp.AppRegistry.stop(e)}}()},961:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t;var n,r="ccp";e.connect.agentApp.AppRegistry=(n={},{register:function(e,t,r){n[e]={containerDOM:r,endpoint:t.endpoint,style:t.style,instance:void 0,onLoad:t.onLoad}},start:function(e,t){if(n[e]){var o=n[e].containerDOM,i=n[e].endpoint,a=n[e].style,s=n[e].onLoad;if(e!==r){var c=function(e,t,n,r){var o=document.createElement("iframe");return o.src=t,o.style=n||"width: 100%; height:100%;",o.id=e,o["aria-label"]=e,o.onload=r,o.allow="clipboard-read; clipboard-write",o.setAttribute("sandbox","allow-forms allow-popups allow-popups-to-escape-sandbox allow-same-origin allow-scripts"),o}(e,i,a,s);o.appendChild(c)}return n[e].instance=t(n[e]),n[e].instance.init()}},get:function(e){return n[e]},delete:function(e){delete n[e]},stop:function(e){if(n[e]){var t,r=n[e],o=r.containerDOM.querySelector("iframe");if(e.includes("customviews")){var i="iframe[id='".concat(e,"']");o=r.containerDOM.querySelector(i)}return r.containerDOM.removeChild(o),r.instance&&(t=r.instance.destroy(),delete r.instance),t}}})}()},610:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var r=null!=arguments[n]?arguments[n]:{};n%2?t(Object(r),!0).forEach((function(t){l(e,t,r[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(r)):t(Object(r)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(r,t))}))}return e}function r(){"use strict";r=function(){return n};var t,n={},o=Object.prototype,i=o.hasOwnProperty,a=Object.defineProperty||function(e,t,n){e[t]=n.value},s="function"==typeof Symbol?Symbol:{},c=s.iterator||"@@iterator",u=s.asyncIterator||"@@asyncIterator",l=s.toStringTag||"@@toStringTag";function p(e,t,n){return Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}),e[t]}try{p({},"")}catch(t){p=function(e,t,n){return e[t]=n}}function d(e,t,n,r){var o=t&&t.prototype instanceof b?t:b,i=Object.create(o.prototype),s=new N(r||[]);return a(i,"_invoke",{value:R(e,n,s)}),i}function f(e,t,n){try{return{type:"normal",arg:e.call(t,n)}}catch(e){return{type:"throw",arg:e}}}n.wrap=d;var h="suspendedStart",g="suspendedYield",m="executing",v="completed",y={};function b(){}function E(){}function S(){}var C={};p(C,c,(function(){return this}));var T=Object.getPrototypeOf,I=T&&T(T(P([])));I&&I!==o&&i.call(I,c)&&(C=I);var w=S.prototype=b.prototype=Object.create(C);function A(e){["next","throw","return"].forEach((function(t){p(e,t,(function(e){return this._invoke(t,e)}))}))}function _(t,n){function r(o,a,s,c){var u=f(t[o],t,a);if("throw"!==u.type){var l=u.arg,p=l.value;return p&&"object"==e(p)&&i.call(p,"__await")?n.resolve(p.__await).then((function(e){r("next",e,s,c)}),(function(e){r("throw",e,s,c)})):n.resolve(p).then((function(e){l.value=e,s(l)}),(function(e){return r("throw",e,s,c)}))}c(u.arg)}var o;a(this,"_invoke",{value:function(e,t){function i(){return new n((function(n,o){r(e,t,n,o)}))}return o=o?o.then(i,i):i()}})}function R(e,n,r){var o=h;return function(i,a){if(o===m)throw Error("Generator is already running");if(o===v){if("throw"===i)throw a;return{value:t,done:!0}}for(r.method=i,r.arg=a;;){var s=r.delegate;if(s){var c=O(s,r);if(c){if(c===y)continue;return c}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(o===h)throw o=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);o=m;var u=f(e,n,r);if("normal"===u.type){if(o=r.done?v:g,u.arg===y)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(o=v,r.method="throw",r.arg=u.arg)}}}function O(e,n){var r=n.method,o=e.iterator[r];if(o===t)return n.delegate=null,"throw"===r&&e.iterator.return&&(n.method="return",n.arg=t,O(e,n),"throw"===n.method)||"return"!==r&&(n.method="throw",n.arg=new TypeError("The iterator does not provide a '"+r+"' method")),y;var i=f(o,e.iterator,n.arg);if("throw"===i.type)return n.method="throw",n.arg=i.arg,n.delegate=null,y;var a=i.arg;return a?a.done?(n[e.resultName]=a.value,n.next=e.nextLoc,"return"!==n.method&&(n.method="next",n.arg=t),n.delegate=null,y):a:(n.method="throw",n.arg=new TypeError("iterator result is not an object"),n.delegate=null,y)}function L(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function k(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function N(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(L,this),this.reset(!0)}function P(n){if(n||""===n){var r=n[c];if(r)return r.call(n);if("function"==typeof n.next)return n;if(!isNaN(n.length)){var o=-1,a=function e(){for(;++o<n.length;)if(i.call(n,o))return e.value=n[o],e.done=!1,e;return e.value=t,e.done=!0,e};return a.next=a}}throw new TypeError(e(n)+" is not iterable")}return E.prototype=S,a(w,"constructor",{value:S,configurable:!0}),a(S,"constructor",{value:E,configurable:!0}),E.displayName=p(S,l,"GeneratorFunction"),n.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===E||"GeneratorFunction"===(t.displayName||t.name))},n.mark=function(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,S):(e.__proto__=S,p(e,l,"GeneratorFunction")),e.prototype=Object.create(w),e},n.awrap=function(e){return{__await:e}},A(_.prototype),p(_.prototype,u,(function(){return this})),n.AsyncIterator=_,n.async=function(e,t,r,o,i){void 0===i&&(i=Promise);var a=new _(d(e,t,r,o),i);return n.isGeneratorFunction(t)?a:a.next().then((function(e){return e.done?e.value:a.next()}))},A(w),p(w,l,"Generator"),p(w,c,(function(){return this})),p(w,"toString",(function(){return"[object Generator]"})),n.keys=function(e){var t=Object(e),n=[];for(var r in t)n.push(r);return n.reverse(),function e(){for(;n.length;){var r=n.pop();if(r in t)return e.value=r,e.done=!1,e}return e.done=!0,e}},n.values=P,N.prototype={constructor:N,reset:function(e){if(this.prev=0,this.next=0,this.sent=this._sent=t,this.done=!1,this.delegate=null,this.method="next",this.arg=t,this.tryEntries.forEach(k),!e)for(var n in this)"t"===n.charAt(0)&&i.call(this,n)&&!isNaN(+n.slice(1))&&(this[n]=t)},stop:function(){this.done=!0;var e=this.tryEntries[0].completion;if("throw"===e.type)throw e.arg;return this.rval},dispatchException:function(e){if(this.done)throw e;var n=this;function r(r,o){return s.type="throw",s.arg=e,n.next=r,o&&(n.method="next",n.arg=t),!!o}for(var o=this.tryEntries.length-1;o>=0;--o){var a=this.tryEntries[o],s=a.completion;if("root"===a.tryLoc)return r("end");if(a.tryLoc<=this.prev){var c=i.call(a,"catchLoc"),u=i.call(a,"finallyLoc");if(c&&u){if(this.prev<a.catchLoc)return r(a.catchLoc,!0);if(this.prev<a.finallyLoc)return r(a.finallyLoc)}else if(c){if(this.prev<a.catchLoc)return r(a.catchLoc,!0)}else{if(!u)throw Error("try statement without catch or finally");if(this.prev<a.finallyLoc)return r(a.finallyLoc)}}}},abrupt:function(e,t){for(var n=this.tryEntries.length-1;n>=0;--n){var r=this.tryEntries[n];if(r.tryLoc<=this.prev&&i.call(r,"finallyLoc")&&this.prev<r.finallyLoc){var o=r;break}}o&&("break"===e||"continue"===e)&&o.tryLoc<=t&&t<=o.finallyLoc&&(o=null);var a=o?o.completion:{};return a.type=e,a.arg=t,o?(this.method="next",this.next=o.finallyLoc,y):this.complete(a)},complete:function(e,t){if("throw"===e.type)throw e.arg;return"break"===e.type||"continue"===e.type?this.next=e.arg:"return"===e.type?(this.rval=this.arg=e.arg,this.method="return",this.next="end"):"normal"===e.type&&t&&(this.next=t),y},finish:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.finallyLoc===e)return this.complete(n.completion,n.afterLoc),k(n),y}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.tryLoc===e){var r=n.completion;if("throw"===r.type){var o=r.arg;k(n)}return o}}throw Error("illegal catch attempt")},delegateYield:function(e,n,r){return this.delegate={iterator:P(e),resultName:n,nextLoc:r},"next"===this.method&&(this.arg=t),y}},n}function o(e,t,n,r,o,i,a){try{var s=e[i](a),c=s.value}catch(e){return void n(e)}s.done?t(c):Promise.resolve(c).then(r,o)}function i(e){return function(){var t=this,n=arguments;return new Promise((function(r,i){var a=e.apply(t,n);function s(e){o(a,r,i,s,c,"next",e)}function c(e){o(a,r,i,s,c,"throw",e)}s(void 0)}))}}function a(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(e){if("string"==typeof e)return s(e,t);var n={}.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?s(e,t):void 0}}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,o=function(){};return{s:o,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var i,a=!0,c=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return a=e.done,e},e:function(e){c=!0,i=e},f:function(){try{a||null==n.return||n.return()}finally{if(c)throw i}}}}function s(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function c(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,p(r.key),r)}}function u(e,t,n){return t&&c(e.prototype,t),n&&c(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function l(e,t,n){return(t=p(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function p(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t,t.AgentStateType=t.makeEnum(["init","routable","not_routable","offline","system","error"]),t.AgentStatusType=t.AgentStateType,t.AgentAvailStates=t.makeEnum(["Init","Busy","AfterCallWork","CallingCustomer","Dialing","Joining","PendingAvailable","PendingBusy"]),t.AgentErrorStates=t.makeEnum(["Error","AgentHungUp","BadAddressAgent","BadAddressCustomer","Default","FailedConnectAgent","FailedConnectCustomer","InvalidLocale","LineEngagedAgent","LineEngagedCustomer","MissedCallAgent","MissedCallCustomer","MultipleCcpWindows","RealtimeCommunicationError"]),t.EndpointType=t.makeEnum(["phone_number","agent","queue"]),t.AddressType=t.EndpointType,t.ConnectionType=t.makeEnum(["agent","inbound","outbound","monitoring"]),t.ConnectionStateType=t.makeEnum(["init","connecting","connected","hold","disconnected","silent_monitor","barge"]),t.ConnectionStatusType=t.ConnectionStateType,t.CONNECTION_ACTIVE_STATES=t.set([t.ConnectionStateType.CONNECTING,t.ConnectionStateType.CONNECTED,t.ConnectionStateType.HOLD,t.ConnectionStateType.SILENT_MONITOR,t.ConnectionStateType.BARGE]),t.CONNECTION_CONNECTED_STATES=t.set([t.ConnectionStateType.CONNECTED,t.ConnectionStateType.SILENT_MONITOR,t.ConnectionStateType.BARGE]),t.ContactStateType=t.makeEnum(["init","incoming","pending","connecting","connected","missed","error","ended","rejected","paused"]),t.ContactStatusType=t.ContactStateType,t.CONTACT_ACTIVE_STATES=t.makeEnum(["paused","incoming","pending","connecting","connected"]),t.ContactType=t.makeEnum(["voice","queue_callback","chat","task","email"]),t.ContactInitiationMethod=t.makeEnum(["inbound","outbound","transfer","queue_transfer","callback","api","disconnect","webrtc_api","agent_reply"]),t.MonitoringMode=t.makeEnum(["SILENT_MONITOR","BARGE"]),t.MonitoringErrorTypes=t.makeEnum(["invalid_target_state"]),t.ChannelType=t.makeEnum(["VOICE","CHAT","TASK"]),t.MediaType=t.makeEnum(["softphone","chat","task","email"]),t.SoftphoneCallType=t.makeEnum(["audio_video","video_only","audio_only","none"]),t.SoftphoneErrorTypes=t.makeEnum(["unsupported_browser","microphone_not_shared","signalling_handshake_failure","signalling_connection_failure","ice_collection_timeout","user_busy_error","webrtc_error","realtime_communication_error","vdi_strategy_not_supported","vdi_redir_not_supported","other"]),t.ClickType=t.makeEnum(["Accept","Reject","Hangup"]),t.VoiceIdErrorTypes=t.makeEnum(["no_speaker_id_found","speaker_id_not_enrolled","get_speaker_id_failed","get_speaker_status_failed","opt_out_speaker_failed","opt_out_speaker_in_lcms_failed","delete_speaker_failed","start_session_failed","evaluate_speaker_failed","session_not_exists","describe_session_failed","enroll_speaker_failed","update_speaker_id_failed","update_speaker_id_in_lcms_failed","not_supported_on_conference_calls","enroll_speaker_timeout","evaluate_speaker_timeout","get_domain_id_failed","no_domain_id_found"]),t.CTIExceptions=t.makeEnum(["AccessDeniedException","InvalidStateException","BadEndpointException","InvalidAgentARNException","InvalidConfigurationException","InvalidContactTypeException","PaginationException","RefreshTokenExpiredException","SendDataFailedException","UnauthorizedException","QuotaExceededException"]),t.VoiceIdStreamingStatus=t.makeEnum(["ONGOING","ENDED","PENDING_CONFIGURATION"]),t.VoiceIdAuthenticationDecision=t.makeEnum(["ACCEPT","REJECT","NOT_ENOUGH_SPEECH","SPEAKER_NOT_ENROLLED","SPEAKER_OPTED_OUT","SPEAKER_ID_NOT_PROVIDED","SPEAKER_EXPIRED"]),t.VoiceIdFraudDetectionDecision=t.makeEnum(["NOT_ENOUGH_SPEECH","HIGH_RISK","LOW_RISK"]),t.ContactFlowAuthenticationDecision=t.makeEnum(["Authenticated","NotAuthenticated","Inconclusive","NotEnrolled","OptedOut","NotEnabled","Error"]),t.ContactFlowFraudDetectionDecision=t.makeEnum(["HighRisk","LowRisk","Inconclusive","NotEnabled","Error"]),t.VideoCapability=t.makeEnum(["SEND"]),t.ScreenShareCapability=t.makeEnum(["SEND"]),t.VoiceIdEnrollmentRequestStatus=t.makeEnum(["NOT_ENOUGH_SPEECH","IN_PROGRESS","COMPLETED","FAILED"]),t.VoiceIdSpeakerStatus=t.makeEnum(["OPTED_OUT","ENROLLED","PENDING"]),t.VoiceIdConstants={EVALUATE_SESSION_DELAY:1e4,EVALUATION_MAX_POLL_TIMES:24,EVALUATION_POLLING_INTERVAL:5e3,ENROLLMENT_MAX_POLL_TIMES:120,ENROLLMENT_POLLING_INTERVAL:5e3,START_SESSION_DELAY:8e3},t.AgentPermissions={OUTBOUND_CALL:"outboundCall",VOICE_ID:"voiceId"};var o=u((function e(){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e)}));l(o,"isEnabled",(function(){var e=t.isCRM()?t.core.getClient():t.core.getApiProxyClient();return new Promise((function(n,r){e.call(t.ApiProxyClientMethods.QR_INTEGRATION_EXISTS,null,{success:function(e){t.getLog().info("Quick Responses isEnabled succeeded").withObject(e).sendInternalLogToServer(),n(e)},failure:function(e){t.getLog().error("Quick Responses isEnabled failed").withException(e).sendInternalLogToServer(),r(e)}})}))})),l(o,"searchQuickResponses",(function(e){var r=t.isCRM()?t.core.getClient():t.core.getApiProxyClient(),o=null!=e&&e.contactId?new p(e.contactId).getAttributes():void 0;return new Promise((function(i,a){r.call(t.ApiProxyClientMethods.QR_SEARCH_QUICK_RESPONSES,n(n({},e),{},{attributes:o}),{success:function(e){t.getLog().info("searchQuickResponses succeeded").withObject(e).sendInternalLogToServer(),i(e)},failure:function(e){t.getLog().error("searchQuickResponses failed").withException(e).sendInternalLogToServer(),a(e)}})}))}));var s=function(){if(!t.agent.initialized)throw new t.StateError("The agent is not yet initialized!")};s.prototype._getData=function(){return t.core.getAgentDataProvider().getAgentData()},s.prototype._createContactAPI=function(e){return new t.Contact(e.contactId)},s.prototype.onRefresh=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.REFRESH,e)},s.prototype.onRoutable=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.ROUTABLE,e)},s.prototype.onNotRoutable=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.NOT_ROUTABLE,e)},s.prototype.onOffline=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.OFFLINE,e)},s.prototype.onError=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.ERROR,e)},s.prototype.onSoftphoneError=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.SOFTPHONE_ERROR,e)},s.prototype.onWebSocketConnectionLost=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.WEBSOCKET_CONNECTION_LOST,e)},s.prototype.onWebSocketConnectionGained=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.WEBSOCKET_CONNECTION_GAINED,e)},s.prototype.onAfterCallWork=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.ACW,e)},s.prototype.onStateChange=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.STATE_CHANGE,e)},s.prototype.onMuteToggle=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.MUTE_TOGGLE,e)},s.prototype.onLocalMediaStreamCreated=function(e){return t.core.getEventBus().subscribe(t.AgentEvents.LOCAL_MEDIA_STREAM_CREATED,e)},s.prototype.onSpeakerDeviceChanged=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.SPEAKER_DEVICE_CHANGED,e)},s.prototype.onMicrophoneDeviceChanged=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.MICROPHONE_DEVICE_CHANGED,e)},s.prototype.onRingerDeviceChanged=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.RINGER_DEVICE_CHANGED,e)},s.prototype.onCameraDeviceChanged=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.CAMERA_DEVICE_CHANGED,e)},s.prototype.onBackgroundBlurChanged=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.BACKGROUND_BLUR_CHANGED,e)},s.prototype.mute=function(){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.EventType.MUTE,data:{mute:!0}})},s.prototype.unmute=function(){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.EventType.MUTE,data:{mute:!1}})},s.prototype.setSpeakerDevice=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.SET_SPEAKER_DEVICE,data:{deviceId:e}})},s.prototype.setMicrophoneDevice=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.SET_MICROPHONE_DEVICE,data:{deviceId:e}})},s.prototype.setRingerDevice=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.SET_RINGER_DEVICE,data:{deviceId:e}})},s.prototype.setCameraDevice=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.CAMERA_DEVICE_CHANGED,data:{deviceId:e}})},s.prototype.setBackgroundBlur=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.BACKGROUND_BLUR_CHANGED,data:{isBackgroundBlurEnabled:e}})},s.prototype.getState=function(){return this._getData().snapshot.state},s.prototype.getNextState=function(){return this._getData().snapshot.nextState},s.prototype.getAvailabilityState=function(){return this._getData().snapshot.agentAvailabilityState},s.prototype.getStatus=s.prototype.getState,s.prototype.getStateDuration=function(){return t.now()-this._getData().snapshot.state.startTimestamp.getTime()+t.core.getSkew()},s.prototype.getStatusDuration=s.prototype.getStateDuration,s.prototype.getPermissions=function(){return this.getConfiguration().permissions},s.prototype.getContacts=function(e){var t=this;return this._getData().snapshot.contacts.map((function(e){return t._createContactAPI(e)})).filter((function(t){return!e||t.getType()===e}))},s.prototype.getConfiguration=function(){return this._getData().configuration},s.prototype.getAgentStates=function(){return this.getConfiguration().agentStates},s.prototype.getRoutingProfile=function(){return this.getConfiguration().routingProfile},s.prototype.getChannelConcurrency=function(e){var n=this.getRoutingProfile().channelConcurrencyMap;return n||(n=Object.keys(t.ChannelType).reduce((function(e,n){return"TASK"!==n&&(e[t.ChannelType[n]]=1),e}),{})),e?n[e]||0:n},s.prototype.getName=function(){return this.getConfiguration().name},s.prototype.getAgentARN=function(){return this.getConfiguration().agentARN},s.prototype.getExtension=function(){return this.getConfiguration().extension},s.prototype.getDialableCountries=function(){return this.getConfiguration().dialableCountries},s.prototype.isSoftphoneEnabled=function(){return this.getConfiguration().softphoneEnabled},s.prototype.setConfiguration=function(e,n){var r=t.core.getClient();e&&e.agentPreferences&&e.agentPreferences.LANGUAGE&&!e.agentPreferences.locale&&(e.agentPreferences.locale=e.agentPreferences.LANGUAGE),e&&e.agentPreferences&&!t.isValidLocale(e.agentPreferences.locale)?n&&n.failure&&n.failure(t.AgentErrorStates.INVALID_LOCALE):r.call(t.ClientMethods.UPDATE_AGENT_CONFIGURATION,{configuration:t.assertNotNull(e,"configuration")},{success:function(e){t.core.getUpstream().sendUpstream(t.EventType.RELOAD_AGENT_CONFIGURATION),n.success&&n.success(e)},failure:n&&n.failure})},s.prototype.setState=function(e,n,r){t.core.getClient().call(t.ClientMethods.PUT_AGENT_STATE,{state:t.assertNotNull(e,"state"),enqueueNextState:r&&!!r.enqueueNextState},n)},s.prototype.onEnqueuedNextState=function(e){t.core.getEventBus().subscribe(t.AgentEvents.ENQUEUED_NEXT_STATE,e)},s.prototype.setStatus=s.prototype.setState,s.prototype.connect=function(e,n){var r=t.core.getClient(),o=new t.Endpoint(e);delete o.endpointId;var i={endpoint:t.assertNotNull(o,"endpoint"),queueARN:n&&(n.queueARN||n.queueId)||this.getRoutingProfile().defaultOutboundQueue.queueARN};n&&n.relatedContactId&&null!==n.relatedContactId&&(i.relatedContactId=n.relatedContactId,n.previousContactId&&delete i.previousContactId),r.call(t.ClientMethods.CREATE_OUTBOUND_CONTACT,i,n&&{success:n.success,failure:n.failure})},s.prototype.getAllQueueARNs=function(){return this.getConfiguration().routingProfile.queues.map((function(e){return e.queueARN}))},s.prototype.getEndpoints=function(e,n,r){var o=this,i=t.core.getClient();t.assertNotNull(n,"callbacks"),t.assertNotNull(n.success,"callbacks.success");var a=r||{};a.endpoints=a.endpoints||[],a.maxResults=a.maxResults||t.DEFAULT_BATCH_SIZE,t.isArray(e)||(e=[e]),i.call(t.ClientMethods.GET_ENDPOINTS,{queueARNs:e,nextToken:a.nextToken||null,maxResults:a.maxResults},{success:function(r){if(r.nextToken)o.getEndpoints(e,n,{nextToken:r.nextToken,maxResults:a.maxResults,endpoints:a.endpoints.concat(r.endpoints)});else{a.endpoints=a.endpoints.concat(r.endpoints);var i=a.endpoints.map((function(e){return new t.Endpoint(e)}));n.success({endpoints:i,addresses:i})}},failure:n.failure})},s.prototype.getAddresses=s.prototype.getEndpoints,s.prototype._getResourceId=function(){var e,t=this.getAllQueueARNs(),n=a(t);try{for(n.s();!(e=n.n()).done;){var r=e.value.match(/\/agent\/([^/]+)/);if(r)return r[1]}}catch(e){n.e(e)}finally{n.f()}return new Error("Agent.prototype._getResourceId: queueArns did not contain agentResourceId: ",t)},s.prototype.toSnapshot=function(){return new t.AgentSnapshot(this._getData())};var c=function(e){t.Agent.call(this),this.agentData=e};(c.prototype=Object.create(s.prototype)).constructor=c,c.prototype._getData=function(){return this.agentData},c.prototype._createContactAPI=function(e){return new t.ContactSnapshot(e)};var p=function(e){this.contactId=e};p.prototype._getData=function(){return t.core.getAgentDataProvider().getContactData(this.getContactId())},p.prototype._createConnectionAPI=function(e){return this.getType()===t.ContactType.CHAT?new t.ChatConnection(this.contactId,e.connectionId):this.getType()===t.ContactType.TASK?new t.TaskConnection(this.contactId,e.connectionId):this.getType()===t.ContactType.EMAIL?new t.EmailConnection(this.contactId,e.connectionId):new t.VoiceConnection(this.contactId,e.connectionId)},p.prototype.getEventName=function(e){return t.core.getContactEventName(e,this.getContactId())},p.prototype.onRefresh=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.REFRESH),e)},p.prototype.onIncoming=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.INCOMING),e)},p.prototype.onConnecting=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.CONNECTING),e)},p.prototype.onPending=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.PENDING),e)},p.prototype.onAccepted=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.ACCEPTED),e)},p.prototype.onMissed=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.MISSED),e)},p.prototype.onEnded=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.ENDED),e)},p.prototype.onDestroy=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.DESTROYED),e)},p.prototype.onACW=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.ACW),e)},p.prototype.onConnected=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.CONNECTED),e)},p.prototype.onError=function(e){return t.core.getEventBus().subscribe(this.getEventName(t.ContactEvents.ERROR),e)},p.prototype.getContactId=function(){return this.contactId},p.prototype.getOriginalContactId=function(){return this._getData().initialContactId},p.prototype.getInitialContactId=p.prototype.getOriginalContactId,p.prototype.getType=function(){return this._getData().type},p.prototype.getContactDuration=function(){return this._getData().contactDuration},p.prototype.getState=function(){return this._getData().state},p.prototype.getStatus=p.prototype.getState,p.prototype.getStateDuration=function(){return t.now()-this._getData().state.timestamp.getTime()+t.core.getSkew()},p.prototype.getStatusDuration=p.prototype.getStateDuration,p.prototype.getQueue=function(){return this._getData().queue},p.prototype.getQueueTimestamp=function(){return this._getData().queueTimestamp},p.prototype.getConnections=function(){var e=this;return this._getData().connections.map((function(n){return e.getType()===t.ContactType.CHAT?new t.ChatConnection(e.contactId,n.connectionId):e.getType()===t.ContactType.TASK?new t.TaskConnection(e.contactId,n.connectionId):e.getType()===t.ContactType.EMAIL?new t.EmailConnection(e.contactId,n.connectionId):new t.VoiceConnection(e.contactId,n.connectionId)}))},p.prototype.getInitialConnection=function(){return t.find(this.getConnections(),(function(e){return e.isInitialConnection()}))||null},p.prototype.getActiveInitialConnection=function(){var e=this.getInitialConnection();return null!=e&&e.isActive()?e:null},p.prototype.getThirdPartyConnections=function(){return this.getConnections().filter((function(e){return!e.isInitialConnection()&&e.getType()!==t.ConnectionType.AGENT}))},p.prototype.getSingleActiveThirdPartyConnection=function(){return this.getThirdPartyConnections().filter((function(e){return e.isActive()}))[0]||null},p.prototype.getAgentConnection=function(){return t.find(this.getConnections(),(function(e){var n=e.getType();return n===t.ConnectionType.AGENT||n===t.ConnectionType.MONITORING}))},p.prototype.getActiveConnections=function(){return this.getConnections().filter((function(e){return e.isActive()}))},p.prototype.hasTwoActiveParticipants=function(){return 2===this.getActiveConnections().length},p.prototype.getName=function(){return this._getData().name},p.prototype.getInitiationMethod=function(){return this._getData().initiationMethod},p.prototype.getContactMetadata=function(){return this._getData().contactMetadata},p.prototype.getDescription=function(){return this._getData().description},p.prototype.getRelatedContactId=function(){return this._getData().relatedContactId},p.prototype.getCustomerEndpoint=function(){return this._getData().customerEndpoint},p.prototype.getConnectSystemEndpoint=function(){return this._getData().connectSystemEndpoint},p.prototype.getReferences=function(){return this._getData().references},p.prototype.getAttributes=function(){return this._getData().attributes},p.prototype.getContactFeatures=function(){return this._getData().contactFeatures},p.prototype.getChannelContext=function(){return this._getData().channelContext},p.prototype.getSegmentAttributes=function(){return this._getData().segmentAttributes},p.prototype.getContactSubtype=function(){var e=this.getSegmentAttributes();return e&&e["connect:Subtype"]?e["connect:Subtype"].ValueString:null},p.prototype.isSoftphoneCall=function(){return null!=t.find(this.getConnections(),(function(e){return null!=e.getSoftphoneMediaInfo()}))},p.prototype.hasVideoRTCCapabilities=function(){return null!==t.find(this.getConnections(),(function(e){return e.canSendVideo&&e.canSendVideo()}))},p.prototype.canAgentSendVideo=function(){var e=this.getAgentConnection();return e.canSendVideo&&e.canSendVideo()},p.prototype.canAgentReceiveVideo=function(){var e=this.getInitialConnection();if(e.canSendVideo&&e.canSendVideo())return!0;var t=this.getThirdPartyConnections();return t&&t.length>0&&this.canAgentSendVideo()},p.prototype.hasScreenShareCapability=function(){return null!==t.find(this.getConnections(),(function(e){return e.canSendScreenShare&&e.canSendScreenShare()}))},p.prototype.canAgentSendScreenShare=function(){var e=this.getAgentConnection();return e.canSendScreenShare&&e.canSendScreenShare()},p.prototype.canCustomerSendScreenShare=function(){var e=this.getInitialConnection();return e.canSendScreenShare&&e.canSendScreenShare()},p.prototype.startScreenSharing=function(){var e=i(r().mark((function e(n){var o,i,a;return r().wrap((function(e){for(;;)switch(e.prev=e.next){case 0:if(o=this.getContactId(),"connect:WebRTC"===this.getContactSubtype()){e.next=3;break}throw new Error("Screen sharing is only supported for WebRTC contacts.");case 3:if(this.isConnected()){e.next=5;break}throw new t.StateError("Contact %s is not connected.",o);case 5:if(n){e.next=11;break}return i=t.isCRM()?t.core.getClient():t.core.getApiProxyClient(),a={InstanceId:t.core.getAgentDataProvider().getInstanceId(),ContactId:o,ParticipantId:this.getAgentConnection().getConnectionId()},e.abrupt("return",new Promise((function(e,n){i.call(t.ApiProxyClientMethods.START_SCREEN_SHARING,a,{success:function(n){t.getLog().info("startScreenSharing succeeded").withObject(n).sendInternalLogToServer(),t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.SCREEN_SHARING_STARTED,data:{contactId:o}}),e(n)},failure:function(e){t.getLog().error("startScreenSharing failed").withException(e).sendInternalLogToServer(),t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.SCREEN_SHARING_ERROR,data:{contactId:o}}),n(e)}})})));case 11:t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.SCREEN_SHARING_STARTED,data:{contactId:o}});case 12:case"end":return e.stop()}}),e,this)})));return function(t){return e.apply(this,arguments)}}(),p.prototype.onScreenSharingStarted=function(e){return t.core.getEventBus().subscribe(t.ContactEvents.SCREEN_SHARING_STARTED,e)},p.prototype.stopScreenSharing=i(r().mark((function e(){var n;return r().wrap((function(e){for(;;)switch(e.prev=e.next){case 0:if(n=this.getContactId(),"connect:WebRTC"===this.getContactSubtype()){e.next=3;break}throw new Error("Screen sharing is only supported for WebRTC contacts.");case 3:if(this.isConnected()){e.next=5;break}throw new t.StateError("Contact %s is not connected.",n);case 5:t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.SCREEN_SHARING_STOPPED,data:{contactId:n}});case 6:case"end":return e.stop()}}),e,this)}))),p.prototype.onScreenSharingStopped=function(e){return t.core.getEventBus().subscribe(t.ContactEvents.SCREEN_SHARING_STOPPED,e)},p.prototype.onScreenSharingError=function(e){return t.core.getEventBus().subscribe(t.ContactEvents.SCREEN_SHARING_ERROR,e)},p.prototype._isInbound=function(){return this._getData().initiationMethod!==t.ContactInitiationMethod.OUTBOUND},p.prototype.isInbound=function(){var e=this.getInitialConnection();return[t.MediaType.TASK,t.MediaType.EMAIL].includes(e.getMediaType())?this._isInbound():!!e&&e.getType()===t.ConnectionType.INBOUND},p.prototype.isConnected=function(){return this.getStatus().type===t.ContactStateType.CONNECTED},p.prototype.accept=function(e){var n=t.core.getClient(),r=this,o=this.getContactId();t.publishClickStreamData({contactId:this.getContactId(),clickType:t.ClickType.ACCEPT,clickTime:(new Date).toISOString()}),n.call(t.ClientMethods.ACCEPT_CONTACT,{contactId:o},{success:function(n){var i=t.core.getUpstream();i.sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.ACCEPTED,data:new t.Contact(o)}),i.sendUpstream(t.EventType.BROADCAST,{event:t.core.getContactEventName(t.ContactEvents.ACCEPTED,r.getContactId()),data:new t.Contact(o)});var a=new t.Contact(o);t.isFirefoxBrowser()&&a.isSoftphoneCall()&&t.core.triggerReadyToStartSessionEvent(),e&&e.success&&e.success(n)},failure:function(n,r){t.getLog().error("Accept Contact failed").sendInternalLogToServer().withException(n).withObject({data:r}),t.publishMetric({name:"ContactAcceptFailure",data:{count:1}}),e&&e.failure&&e.failure(t.ContactStateType.ERROR)}})},p.prototype.destroy=function(){t.getLog().warn("contact.destroy() has been deprecated.")},p.prototype.reject=function(e){var n=t.core.getClient();t.publishClickStreamData({contactId:this.getContactId(),clickType:t.ClickType.REJECT,clickTime:(new Date).toISOString()}),n.call(t.ClientMethods.REJECT_CONTACT,{contactId:this.getContactId()},e)},p.prototype.complete=function(e){t.core.getClient().call(t.ClientMethods.COMPLETE_CONTACT,{contactId:this.getContactId()},e)},p.prototype.clear=function(e){t.core.getClient().call(t.ClientMethods.CLEAR_CONTACT,{contactId:this.getContactId()},e)},p.prototype.notifyIssue=function(e,n,r){t.core.getClient().call(t.ClientMethods.NOTIFY_CONTACT_ISSUE,{contactId:this.getContactId(),issueCode:e,description:n},r)},p.prototype.addConnection=function(e,n){var r=t.core.getClient(),o=new t.Endpoint(e);delete o.endpointId,r.call(t.ClientMethods.CREATE_ADDITIONAL_CONNECTION,{contactId:this.getContactId(),endpoint:o},n)},p.prototype.toggleActiveConnections=function(e){var n=t.core.getClient(),r=null,o=t.find(this.getConnections(),(function(e){return e.getStatus().type===t.ConnectionStateType.HOLD}));if(null!=o)r=o.getConnectionId();else{var i=this.getConnections().filter((function(e){return e.isActive()}));i.length>0&&(r=i[0].getConnectionId())}n.call(t.ClientMethods.TOGGLE_ACTIVE_CONNECTIONS,{contactId:this.getContactId(),connectionId:r},e)},p.prototype.sendSoftphoneMetrics=function(n,r){t.core.getClient().call(t.ClientMethods.SEND_SOFTPHONE_CALL_METRICS,{contactId:this.getContactId(),ccpVersion:e.ccpVersion,softphoneStreamStatistics:n},r),t.publishSoftphoneStats({contactId:this.getContactId(),ccpVersion:e.ccpVersion,stats:n})},p.prototype.sendSoftphoneReport=function(n,r){t.core.getClient().call(t.ClientMethods.SEND_SOFTPHONE_CALL_REPORT,{contactId:this.getContactId(),ccpVersion:e.ccpVersion,report:n},r)},p.prototype.conferenceConnections=function(e){t.core.getClient().call(t.ClientMethods.CONFERENCE_CONNECTIONS,{contactId:this.getContactId()},e)},p.prototype.toSnapshot=function(){return new t.ContactSnapshot(this._getData())},p.prototype.isMultiPartyConferenceEnabled=function(){var e=this.getContactFeatures();return!(!e||!e.multiPartyConferenceEnabled)},p.prototype.updateMonitorParticipantState=function(e,n){e&&Object.values(t.MonitoringMode).includes(e.toUpperCase())?t.core.getClient().call(t.ClientMethods.UPDATE_MONITOR_PARTICIPANT_STATE,{contactId:this.getContactId(),targetMonitorMode:e.toUpperCase()},n):(t.getLog().error("Invalid target state was provided: ".concat(e)).sendInternalLogToServer(),n&&n.failure&&n.failure(t.MonitoringErrorTypes.INVALID_TARGET_STATE))},p.prototype.isUnderSupervision=function(){var e=this.getConnections().filter((function(e){return e.getType()!==t.ConnectionType.AGENT}));return void 0!==(e&&e.find((function(e){return e.isBarge()&&e.isActive()})))},p.prototype.silentMonitor=function(e){return this.updateMonitorParticipantState(t.MonitoringMode.SILENT_MONITOR,e)},p.prototype.bargeIn=function(e){return this.updateMonitorParticipantState(t.MonitoringMode.BARGE,e)},p.prototype.pause=function(e){t.core.getClient().call(t.ClientMethods.PAUSE_CONTACT,{contactId:this.getContactId()},e)},p.prototype.resume=function(e){t.core.getClient().call(t.ClientMethods.RESUME_CONTACT,{contactId:this.getContactId()},e)};var d=function(e){t.Contact.call(this,e.contactId),this.contactData=e};(d.prototype=Object.create(p.prototype)).constructor=d,d.prototype._getData=function(){return this.contactData},d.prototype._createConnectionAPI=function(e){return new t.ConnectionSnapshot(e)};var f=function(e,t){this.contactId=e,this.connectionId=t,this._initMediaController()};f.prototype._getData=function(){return t.core.getAgentDataProvider().getConnectionData(this.getContactId(),this.getConnectionId())},f.prototype.getContactId=function(){return this.contactId},f.prototype.getConnectionId=function(){return this.connectionId},f.prototype.getEndpoint=function(){return new t.Endpoint(this._getData().endpoint)},f.prototype.getAddress=f.prototype.getEndpoint,f.prototype.getState=function(){return this._getData().state},f.prototype.getStatus=f.prototype.getState,f.prototype.getStateDuration=function(){return t.now()-this._getData().state.timestamp.getTime()+t.core.getSkew()},f.prototype.getStatusDuration=f.prototype.getStateDuration,f.prototype.getType=function(){return this._getData().type},f.prototype.isInitialConnection=function(){return this._getData().initial},f.prototype.isActive=function(){return t.contains(t.CONNECTION_ACTIVE_STATES,this.getStatus().type)},f.prototype.isConnected=function(){return t.contains(t.CONNECTION_CONNECTED_STATES,this.getStatus().type)},f.prototype.isConnecting=function(){return this.getStatus().type===t.ConnectionStateType.CONNECTING},f.prototype.isOnHold=function(){return this.getStatus().type===t.ConnectionStateType.HOLD},f.prototype.getSoftphoneMediaInfo=function(){return this._getData().softphoneMediaInfo},f.prototype.getMonitorInfo=function(){return this._getData().monitoringInfo},f.prototype.destroy=function(e){t.publishClickStreamData({contactId:this.getContactId(),clickType:t.ClickType.HANGUP,clickTime:(new Date).toISOString()}),t.core.getClient().call(t.ClientMethods.DESTROY_CONNECTION,{contactId:this.getContactId(),connectionId:this.getConnectionId()},e)},f.prototype.sendDigits=function(e,n){t.core.getClient().call(t.ClientMethods.SEND_DIGITS,{contactId:this.getContactId(),connectionId:this.getConnectionId(),digits:e},n)},f.prototype.hold=function(e){t.core.getClient().call(t.ClientMethods.HOLD_CONNECTION,{contactId:this.getContactId(),connectionId:this.getConnectionId()},e)},f.prototype.resume=function(e){t.core.getClient().call(t.ClientMethods.RESUME_CONNECTION,{contactId:this.getContactId(),connectionId:this.getConnectionId()},e)},f.prototype.toSnapshot=function(){return new t.ConnectionSnapshot(this._getData())},f.prototype._initMediaController=function(){this.getMediaInfo()&&t.core.mediaFactory.get(this).catch((function(){}))},f.prototype._isAgentConnectionType=function(){var e=this.getType();return e===t.ConnectionType.AGENT||e===t.ConnectionType.MONITORING},f.prototype._isAgentConnectionType=function(){var e=this.getType();return e===t.ConnectionType.AGENT||e===t.ConnectionType.MONITORING};var h=function(e){this.contactId=e};h.prototype.getSpeakerId=function(){var e=this;e.checkConferenceCall();var n=t.core.getClient();return new Promise((function(r,o){var i={contactId:e.contactId,instanceId:t.core.getAgentDataProvider().getInstanceId(),awsAccountId:t.core.getAgentDataProvider().getAWSAccountId()};t.getLog().info("getSpeakerId called").withObject(i).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.GET_CONTACT,i,{success:function(e){if(e.contactData.customerId){var n={speakerId:e.contactData.customerId};t.getLog().info("getSpeakerId succeeded").withObject(e).sendInternalLogToServer(),r(n)}else{var i=t.VoiceIdError(t.VoiceIdErrorTypes.NO_SPEAKER_ID_FOUND,"No speakerId assotiated with this call");o(i)}},failure:function(e){t.getLog().error("Get SpeakerId failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.GET_SPEAKER_ID_FAILED,"Get SpeakerId failed",e);o(n)}})}))},h.prototype.getSpeakerStatus=function(){var e=this;e.checkConferenceCall();var n=t.core.getClient();return new Promise((function(r,o){e.getSpeakerId().then((function(i){e.getDomainId().then((function(e){var a={SpeakerId:t.assertNotNull(i.speakerId,"speakerId"),DomainId:e};t.getLog().info("getSpeakerStatus called").withObject(a).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.DESCRIBE_SPEAKER,a,{success:function(e){t.getLog().info("getSpeakerStatus succeeded").withObject(e).sendInternalLogToServer(),r(e)},failure:function(e){var n=JSON.parse(e);switch(n.status){case 400:case 404:var i=n;i.type=i.type?i.type:t.VoiceIdErrorTypes.SPEAKER_ID_NOT_ENROLLED,t.getLog().info("Speaker is not enrolled.").sendInternalLogToServer(),r(i);break;default:t.getLog().error("getSpeakerStatus failed").withObject({err:e}).sendInternalLogToServer();var a=t.VoiceIdError(t.VoiceIdErrorTypes.GET_SPEAKER_STATUS_FAILED,"Get SpeakerStatus failed",e);o(a)}}})})).catch((function(e){o(e)}))})).catch((function(e){o(e)}))}))},h.prototype._optOutSpeakerInLcms=function(e,n){var r=this,o=t.core.getClient();return new Promise((function(i,a){var s={ContactId:r.contactId,InstanceId:t.core.getAgentDataProvider().getInstanceId(),AWSAccountId:t.core.getAgentDataProvider().getAWSAccountId(),CustomerId:t.assertNotNull(e,"speakerId"),VoiceIdResult:{SpeakerOptedOut:!0,generatedSpeakerId:n}};t.getLog().info("_optOutSpeakerInLcms called").withObject(s).sendInternalLogToServer(),o.call(t.AgentAppClientMethods.UPDATE_VOICE_ID_DATA,s,{success:function(e){t.getLog().info("optOutSpeakerInLcms succeeded").withObject(e).sendInternalLogToServer(),i(e)},failure:function(e){t.getLog().error("optOutSpeakerInLcms failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.OPT_OUT_SPEAKER_IN_LCMS_FAILED,"optOutSpeakerInLcms failed",e);a(n)}})}))},h.prototype.optOutSpeaker=function(){var e=this;e.checkConferenceCall();var n=t.core.getClient();return new Promise((function(r,o){e.getSpeakerId().then((function(i){e.getDomainId().then((function(a){var s=i.speakerId,c={SpeakerId:t.assertNotNull(s,"speakerId"),DomainId:a};t.getLog().info("optOutSpeaker called").withObject(c).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.OPT_OUT_SPEAKER,c,{success:function(n){e._optOutSpeakerInLcms(s,n.generatedSpeakerId).catch((function(){})),t.getLog().info("optOutSpeaker succeeded").withObject(n).sendInternalLogToServer(),r(n)},failure:function(e){t.getLog().error("optOutSpeaker failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.OPT_OUT_SPEAKER_FAILED,"optOutSpeaker failed.",e);o(n)}})})).catch((function(e){o(e)}))})).catch((function(e){o(e)}))}))},h.prototype.deleteSpeaker=function(){var e=this;e.checkConferenceCall();var n=t.core.getClient();return new Promise((function(r,o){e.getSpeakerId().then((function(i){e.getDomainId().then((function(e){var a={SpeakerId:t.assertNotNull(i.speakerId,"speakerId"),DomainId:e};t.getLog().info("deleteSpeaker called").withObject(a).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.DELETE_SPEAKER,a,{success:function(e){t.getLog().info("deleteSpeaker succeeded").withObject(e).sendInternalLogToServer(),r(e)},failure:function(e){t.getLog().error("deleteSpeaker failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.DELETE_SPEAKER_FAILED,"deleteSpeaker failed.",e);o(n)}})})).catch((function(e){o(e)}))})).catch((function(e){o(e)}))}))},h.prototype.startSession=function(){var e=this;e.checkConferenceCall();var n=t.core.getClient();return new Promise((function(r,o){e.getDomainId().then((function(i){var a={contactId:e.contactId,instanceId:t.core.getAgentDataProvider().getInstanceId(),customerAccountId:t.core.getAgentDataProvider().getAWSAccountId(),clientToken:AWS.util.uuid.v4(),domainId:i};t.getLog().info("startSession called").withObject(a).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.START_VOICE_ID_SESSION,a,{success:function(e){if(e.sessionId)r(e);else{t.getLog().error("startVoiceIdSession failed, no session id returned").withObject({data:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.START_SESSION_FAILED,"No session id returned from start session api");o(n)}},failure:function(e){t.getLog().error("startVoiceIdSession failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.START_SESSION_FAILED,"startVoiceIdSession failed",e);o(n)}})})).catch((function(e){o(e)}))}))},h.prototype.evaluateSpeaker=function(e){var n=this;n.checkConferenceCall();var r=t.core.getClient(),o=t.core.getAgentDataProvider().getContactData(this.contactId),i=0;return new Promise((function(a,s){function c(){n.getDomainId().then((function(e){var u={SessionNameOrId:o.initialContactId||this.contactId,DomainId:e};t.getLog().info("evaluateSpeaker called").withObject(u).sendInternalLogToServer(),r.call(t.AgentAppClientMethods.EVALUATE_SESSION,u,{success:function(e){if(++i<t.VoiceIdConstants.EVALUATION_MAX_POLL_TIMES)if(e.StreamingStatus===t.VoiceIdStreamingStatus.PENDING_CONFIGURATION)setTimeout(c,t.VoiceIdConstants.EVALUATION_POLLING_INTERVAL);else{if(e.AuthenticationResult||(e.AuthenticationResult={},e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.NOT_ENABLED),e.FraudDetectionResult||(e.FraudDetectionResult={},e.FraudDetectionResult.Decision=t.ContactFlowFraudDetectionDecision.NOT_ENABLED),!n.isAuthEnabled(e.AuthenticationResult.Decision)&&!n.isFraudEnabled(e.FraudDetectionResult.Decision))return t.getLog().info("evaluateSpeaker succeeded").withObject(e).sendInternalLogToServer(),void a(e);if(e.StreamingStatus===t.VoiceIdStreamingStatus.ENDED&&(n.isAuthResultNotEnoughSpeech(e.AuthenticationResult.Decision)&&(e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.INCONCLUSIVE),n.isFraudResultNotEnoughSpeech(e.FraudDetectionResult.Decision)&&(e.FraudDetectionResult.Decision=t.ContactFlowFraudDetectionDecision.INCONCLUSIVE)),n.isAuthResultInconclusive(e.AuthenticationResult.Decision)&&n.isFraudResultInconclusive(e.FraudDetectionResult.Decision))return t.getLog().info("evaluateSpeaker succeeded").withObject(e).sendInternalLogToServer(),void a(e);if(!n.isAuthResultNotEnoughSpeech(e.AuthenticationResult.Decision)&&n.isAuthEnabled(e.AuthenticationResult.Decision))switch(e.AuthenticationResult.Decision){case t.VoiceIdAuthenticationDecision.ACCEPT:e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.AUTHENTICATED;break;case t.VoiceIdAuthenticationDecision.REJECT:e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.NOT_AUTHENTICATED;break;case t.VoiceIdAuthenticationDecision.SPEAKER_OPTED_OUT:e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.OPTED_OUT;break;case t.VoiceIdAuthenticationDecision.SPEAKER_NOT_ENROLLED:e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.NOT_ENROLLED;break;default:e.AuthenticationResult.Decision=t.ContactFlowAuthenticationDecision.ERROR}if(!n.isFraudResultNotEnoughSpeech(e.FraudDetectionResult.Decision)&&n.isFraudEnabled(e.FraudDetectionResult.Decision))switch(e.FraudDetectionResult.Decision){case t.VoiceIdFraudDetectionDecision.HIGH_RISK:e.FraudDetectionResult.Decision=t.ContactFlowFraudDetectionDecision.HIGH_RISK;break;case t.VoiceIdFraudDetectionDecision.LOW_RISK:e.FraudDetectionResult.Decision=t.ContactFlowFraudDetectionDecision.LOW_RISK;break;default:e.FraudDetectionResult.Decision=t.ContactFlowFraudDetectionDecision.ERROR}if(!n.isAuthResultNotEnoughSpeech(e.AuthenticationResult.Decision)&&!n.isFraudResultNotEnoughSpeech(e.FraudDetectionResult.Decision))return t.getLog().info("evaluateSpeaker succeeded").withObject(e).sendInternalLogToServer(),void a(e);setTimeout(c,t.VoiceIdConstants.EVALUATION_POLLING_INTERVAL)}else{t.getLog().error("evaluateSpeaker timeout").sendInternalLogToServer();var r=t.VoiceIdError(t.VoiceIdErrorTypes.EVALUATE_SPEAKER_TIMEOUT,"evaluateSpeaker timeout");s(r)}},failure:function(e){var n;switch(JSON.parse(e).status){case 400:case 404:n=t.VoiceIdError(t.VoiceIdErrorTypes.SESSION_NOT_EXISTS,"evaluateSpeaker failed, session not exists",e),t.getLog().error("evaluateSpeaker failed, session not exists").withObject({err:e}).sendInternalLogToServer();break;default:n=t.VoiceIdError(t.VoiceIdErrorTypes.EVALUATE_SPEAKER_FAILED,"evaluateSpeaker failed",e),t.getLog().error("evaluateSpeaker failed").withObject({err:e}).sendInternalLogToServer()}s(n)}})})).catch((function(e){s(e)}))}e?n.startSession().then((function(e){n.syncSpeakerId().then((function(e){setTimeout(c,t.VoiceIdConstants.EVALUATE_SESSION_DELAY)})).catch((function(e){t.getLog().error("syncSpeakerId failed when session startNew=true").withObject({err:e}).sendInternalLogToServer(),s(e)}))})).catch((function(e){t.getLog().error("startSession failed when session startNew=true").withObject({err:e}).sendInternalLogToServer(),s(e)})):n.syncSpeakerId().then((function(){c()})).catch((function(e){t.getLog().error("syncSpeakerId failed when session startNew=false").withObject({err:e}).sendInternalLogToServer(),s(e)}))}))},h.prototype.describeSession=function(){var e=this,n=t.core.getClient(),r=t.core.getAgentDataProvider().getContactData(this.contactId);return new Promise((function(o,i){e.getDomainId().then((function(e){var a={SessionNameOrId:r.initialContactId||this.contactId,DomainId:e};t.getLog().info("describeSession called").withObject(a).sendInternalLogToServer(),n.call(t.AgentAppClientMethods.DESCRIBE_SESSION,a,{success:function(e){o(e)},failure:function(e){t.getLog().error("describeSession failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.DESCRIBE_SESSION_FAILED,"describeSession failed",e);i(n)}})})).catch((function(e){i(e)}))}))},h.prototype.checkEnrollmentStatus=function(e){t.getLog().info("checkEnrollmentStatus called").sendInternalLogToServer();var n=this,r=0,o=!1;return new Promise((function(i,a){!function s(){if(++r<t.VoiceIdConstants.ENROLLMENT_MAX_POLL_TIMES)n.describeSession().then((function(r){switch(r.Session.EnrollmentRequestDetails.Status){case t.VoiceIdEnrollmentRequestStatus.COMPLETED:i(r);break;case t.VoiceIdEnrollmentRequestStatus.IN_PROGRESS:o||"function"!=typeof e||(e(r),o=!0),setTimeout(s,t.VoiceIdConstants.ENROLLMENT_POLLING_INTERVAL);break;case t.VoiceIdEnrollmentRequestStatus.NOT_ENOUGH_SPEECH:r.Session.StreamingStatus!==t.VoiceIdStreamingStatus.ENDED?setTimeout(s,t.VoiceIdConstants.ENROLLMENT_POLLING_INTERVAL):setTimeout((function(){n.startSession().then((function(e){s()})).catch((function(e,t){a(e)}))}),t.VoiceIdConstants.START_SESSION_DELAY);break;default:var c=r.Session.EnrollmentRequestDetails.Message?r.Session.EnrollmentRequestDetails.Message:"enrollSpeaker failed. Unknown enrollment status has been received";t.getLog().error(c).sendInternalLogToServer();var u=t.VoiceIdError(t.VoiceIdErrorTypes.ENROLL_SPEAKER_FAILED,c,r.Session.EnrollmentRequestDetails.Status);a(u)}}));else{t.getLog().error("enrollSpeaker timeout").sendInternalLogToServer();var c=t.VoiceIdError(t.VoiceIdErrorTypes.ENROLL_SPEAKER_TIMEOUT,"enrollSpeaker timeout");a(c)}}()}))},h.prototype.enrollSpeaker=function(e){t.getLog().info("enrollSpeaker called").sendInternalLogToServer();var n=this;return n.checkConferenceCall(),new Promise((function(r,o){n.syncSpeakerId().then((function(){n.getSpeakerStatus().then((function(i){i.Speaker&&i.Speaker.Status==t.VoiceIdSpeakerStatus.OPTED_OUT?n.deleteSpeaker().then((function(){n.enrollSpeakerHelper(r,o,e)})).catch((function(e){o(e)})):n.enrollSpeakerHelper(r,o,e)})).catch((function(e){o(e)}))})).catch((function(e){o(e)}))}))},h.prototype.enrollSpeakerHelper=function(e,n,r){var o=this,i=t.core.getClient(),a=t.core.getAgentDataProvider().getContactData(this.contactId);o.getDomainId().then((function(s){var c={SessionNameOrId:a.initialContactId||this.contactId,DomainId:s};t.getLog().info("enrollSpeakerHelper called").withObject(c).sendInternalLogToServer(),i.call(t.AgentAppClientMethods.ENROLL_BY_SESSION,c,{success:function(i){i.Status===t.VoiceIdEnrollmentRequestStatus.COMPLETED?(t.getLog().info("enrollSpeaker succeeded").withObject(i).sendInternalLogToServer(),e(i)):o.checkEnrollmentStatus(r).then((function(n){t.getLog().info("enrollSpeaker succeeded").withObject(n).sendInternalLogToServer(),e(n)})).catch((function(e){n(e)}))},failure:function(e){t.getLog().error("enrollSpeaker failed").withObject({err:e}).sendInternalLogToServer();var r=t.VoiceIdError(t.VoiceIdErrorTypes.ENROLL_SPEAKER_FAILED,"enrollSpeaker failed",e);n(r)}})})).catch((function(e){n(e)}))},h.prototype._updateSpeakerIdInLcms=function(e,n){var r=this,o=t.core.getClient();return new Promise((function(i,a){var s={ContactId:r.contactId,InstanceId:t.core.getAgentDataProvider().getInstanceId(),AWSAccountId:t.core.getAgentDataProvider().getAWSAccountId(),CustomerId:t.assertNotNull(e,"speakerId"),VoiceIdResult:{generatedSpeakerId:n}};t.getLog().info("_updateSpeakerIdInLcms called").withObject(s).sendInternalLogToServer(),o.call(t.AgentAppClientMethods.UPDATE_VOICE_ID_DATA,s,{success:function(e){t.getLog().info("updateSpeakerIdInLcms succeeded").withObject(e).sendInternalLogToServer(),i(e)},failure:function(e){t.getLog().error("updateSpeakerIdInLcms failed").withObject({err:e}).sendInternalLogToServer();var n=t.VoiceIdError(t.VoiceIdErrorTypes.UPDATE_SPEAKER_ID_IN_LCMS_FAILED,"updateSpeakerIdInLcms failed",e);a(n)}})}))},h.prototype.updateSpeakerIdInVoiceId=function(e){var n=this;n.checkConferenceCall();var r=t.core.getClient(),o=t.core.getAgentDataProvider().getContactData(this.contactId);return new Promise((function(i,a){n.getDomainId().then((function(s){var c={SessionNameOrId:o.initialContactId||this.contactId,SpeakerId:t.assertNotNull(e,"speakerId"),DomainId:s};t.getLog().info("updateSpeakerIdInVoiceId called").withObject(c).sendInternalLogToServer(),r.call(t.AgentAppClientMethods.UPDATE_SESSION,c,{success:function(r){t.getLog().info("updateSpeakerIdInVoiceId succeeded").withObject(r).sendInternalLogToServer();var o=r&&r.Session&&r.Session.GeneratedSpeakerId;n._updateSpeakerIdInLcms(e,o).then((function(){i(r)})).catch((function(e){a(e)}))},failure:function(e){var n;switch(JSON.parse(e).status){case 400:case 404:n=t.VoiceIdError(t.VoiceIdErrorTypes.SESSION_NOT_EXISTS,"updateSpeakerIdInVoiceId failed, session not exists",e),t.getLog().error("updateSpeakerIdInVoiceId failed, session not exists").withObject({err:e}).sendInternalLogToServer();break;default:n=t.VoiceIdError(t.VoiceIdErrorTypes.UPDATE_SPEAKER_ID_FAILED,"updateSpeakerIdInVoiceId failed",e),t.getLog().error("updateSpeakerIdInVoiceId failed").withObject({err:e}).sendInternalLogToServer()}a(n)}})})).catch((function(e){a(e)}))}))},h.prototype.syncSpeakerId=function(){t.getLog().info("syncSpeakerId called").sendInternalLogToServer();var e=this;return new Promise((function(t,n){e.getSpeakerId().then((function(r){e.updateSpeakerIdInVoiceId(r.speakerId).then((function(e){t(e)})).catch((function(e){n(e)}))})).catch((function(e){n(e)}))}))},h.prototype.getDomainId=function(){return new Promise((function(e,n){if((new t.Agent).getPermissions().includes(t.AgentPermissions.VOICE_ID))if(t.core.voiceIdDomainId)e(t.core.voiceIdDomainId);else{var r=t.core.getClient(),o={InstanceId:t.core.getAgentDataProvider().getInstanceId(),IntegrationType:"VOICE_ID"};t.getLog().info("getDomainId called").withObject(o).sendInternalLogToServer(),r.call(t.AgentAppClientMethods.LIST_INTEGRATION_ASSOCIATIONS,o,{success:function(r){try{var o;if(r.IntegrationAssociationSummaryList.length>=1&&(o=r.IntegrationAssociationSummaryList[0].IntegrationArn.replace(/^.*domain\//i,"")),!o){t.getLog().info("getDomainId: no domainId found").sendInternalLogToServer();var i=t.VoiceIdError(t.VoiceIdErrorTypes.NO_DOMAIN_ID_FOUND);return void n(i)}t.getLog().info("getDomainId succeeded").withObject(r).sendInternalLogToServer(),t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.VoiceIdEvents.UPDATE_DOMAIN_ID,data:{domainId:o}}),e(o)}catch(e){t.getLog().error("getDomainId failed").withObject({err:e}).sendInternalLogToServer(),i=t.VoiceIdError(t.VoiceIdErrorTypes.GET_DOMAIN_ID_FAILED,"getDomainId failed",e),n(i)}},failure:function(e){t.getLog().error("getDomainId failed").withObject({err:e}).sendInternalLogToServer();var r=t.VoiceIdError(t.VoiceIdErrorTypes.GET_DOMAIN_ID_FAILED,"getDomainId failed",e);n(r)}})}else n(new Error("Agent doesn't have the permission for Voice ID"))}))},h.prototype.checkConferenceCall=function(){if(t.core.getAgentDataProvider().getContactData(this.contactId).connections.filter((function(e){return t.contains(t.CONNECTION_ACTIVE_STATES,e.state.type)})).length>2)throw new t.NotImplementedError("VoiceId is not supported for conference calls")},h.prototype.isAuthEnabled=function(e){return e!==t.ContactFlowAuthenticationDecision.NOT_ENABLED},h.prototype.isAuthResultNotEnoughSpeech=function(e){return e===t.VoiceIdAuthenticationDecision.NOT_ENOUGH_SPEECH},h.prototype.isAuthResultInconclusive=function(e){return e===t.ContactFlowAuthenticationDecision.INCONCLUSIVE},h.prototype.isFraudEnabled=function(e){return e!==t.ContactFlowFraudDetectionDecision.NOT_ENABLED},h.prototype.isFraudResultNotEnoughSpeech=function(e){return e===t.VoiceIdFraudDetectionDecision.NOT_ENOUGH_SPEECH},h.prototype.isFraudResultInconclusive=function(e){return e===t.ContactFlowFraudDetectionDecision.INCONCLUSIVE};var g=function(e,t){this._speakerAuthenticator=new h(e),f.call(this,e,t)};(g.prototype=Object.create(f.prototype)).constructor=g,g.prototype.getSoftphoneMediaInfo=function(){return this._getData().softphoneMediaInfo},g.prototype.getMediaInfo=function(){return this._getData().softphoneMediaInfo},g.prototype.getMediaType=function(){return t.MediaType.SOFTPHONE},g.prototype.getMediaController=function(){return t.core.mediaFactory.get(this)},g.prototype.getVoiceIdSpeakerId=function(){return this._speakerAuthenticator.getSpeakerId()},g.prototype.getVoiceIdSpeakerStatus=function(){return this._speakerAuthenticator.getSpeakerStatus()},g.prototype.optOutVoiceIdSpeaker=function(){return this._speakerAuthenticator.optOutSpeaker()},g.prototype.deleteVoiceIdSpeaker=function(){return this._speakerAuthenticator.deleteSpeaker()},g.prototype.evaluateSpeakerWithVoiceId=function(e){return this._speakerAuthenticator.evaluateSpeaker(e)},g.prototype.enrollSpeakerInVoiceId=function(e){return this._speakerAuthenticator.enrollSpeaker(e)},g.prototype.updateVoiceIdSpeakerId=function(e){return this._speakerAuthenticator.updateSpeakerIdInVoiceId(e)},g.prototype.getQuickConnectName=function(){return this._getData().quickConnectName},g.prototype.isSilentMonitor=function(){return this.getMonitorStatus()===t.MonitoringMode.SILENT_MONITOR},g.prototype.isBarge=function(){return this.getMonitorStatus()===t.MonitoringMode.BARGE},g.prototype.isBargeEnabled=function(){var e=this.getMonitorCapabilities();return e&&e.includes(t.MonitoringMode.BARGE)},g.prototype.isSilentMonitorEnabled=function(){var e=this.getMonitorCapabilities();return e&&e.includes(t.MonitoringMode.SILENT_MONITOR)},g.prototype.getMonitorCapabilities=function(){return this._getData().monitorCapabilities},g.prototype.getMonitorStatus=function(){return this._getData().monitorStatus},g.prototype.isMute=function(){return this._getData().mute},g.prototype.isForcedMute=function(){return this._getData().forcedMute},g.prototype.muteParticipant=function(e){t.core.getClient().call(t.ClientMethods.MUTE_PARTICIPANT,{contactId:this.getContactId(),connectionId:this.getConnectionId()},e)},g.prototype.unmuteParticipant=function(e){t.core.getClient().call(t.ClientMethods.UNMUTE_PARTICIPANT,{contactId:this.getContactId(),connectionId:this.getConnectionId()},e)},g.prototype.canSendVideo=function(){var e=this.getCapabilities();return e&&e.Video===t.VideoCapability.SEND},g.prototype.canSendScreenShare=function(){var e=this.getCapabilities();return e&&e.ScreenShare===t.ScreenShareCapability.SEND},g.prototype.getCapabilities=function(){return this._getData().capabilities},g.prototype.getVideoConnectionInfo=function(){var e=t.core.getClient(),n={transportType:t.TRANSPORT_TYPES.WEB_RTC,contactId:this.contactId};return new Promise((function(r,o){e.call(t.ClientMethods.CREATE_TRANSPORT,n,{success:function(e){t.getLog().info("getVideoConnectionInfo succeeded").sendInternalLogToServer(),r(e.webRTCTransport)},failure:function(e,n){t.getLog().error("getVideoConnectionInfo failed").sendInternalLogToServer().withObject({err:e,data:n}),o(Error("getVideoConnectionInfo failed"))}})}))};var m=function(e,t){f.call(this,e,t)};(m.prototype=Object.create(f.prototype)).constructor=m,m.prototype.getMediaInfo=function(){var e=this._getData().chatMediaInfo;if(e){var n=t.core.getAgentDataProvider().getContactData(this.contactId),r={contactId:this.contactId,initialContactId:n.initialContactId||this.contactId,participantId:this.connectionId,getConnectionToken:t.hitch(this,this.getConnectionToken)};if(e.connectionData)try{r.participantToken=JSON.parse(e.connectionData).ConnectionAuthenticationToken}catch(n){t.getLog().error(t.LogComponent.CHAT,"Connection data is invalid").withObject(e).withException(n).sendInternalLogToServer(),r.participantToken=null}return r.participantToken=r.participantToken||null,r.originalInfo=this._getData().chatMediaInfo,r}return null},m.prototype.getConnectionToken=function(){var e=t.core.getClient(),n=(t.core.getAgentDataProvider().getContactData(this.contactId),{transportType:t.TRANSPORT_TYPES.CHAT_TOKEN,participantId:this.connectionId,contactId:this.contactId});return new Promise((function(r,o){e.call(t.ClientMethods.CREATE_TRANSPORT,n,{success:function(e){t.getLog().info("getConnectionToken succeeded").sendInternalLogToServer(),r(e)},failure:function(e,n){t.getLog().error("getConnectionToken failed").sendInternalLogToServer().withObject({err:e,data:n}),o(Error("getConnectionToken failed"))}})}))},m.prototype.getMediaType=function(){return t.MediaType.CHAT},m.prototype.getMediaController=function(){return t.core.mediaFactory.get(this)},m.prototype._initMediaController=function(){this._isAgentConnectionType()&&t.core.mediaFactory.get(this).catch((function(){}))},m.prototype.isBargeEnabled=function(){var e=this.getMonitorCapabilities();return e&&e.includes(t.MonitoringMode.BARGE)},m.prototype.isSilentMonitorEnabled=function(){var e=this.getMonitorCapabilities();return e&&e.includes(t.MonitoringMode.SILENT_MONITOR)},m.prototype.getMonitorCapabilities=function(){return this._getData().monitorCapabilities},m.prototype.isBarge=function(){return this.getMonitorStatus()===t.MonitoringMode.BARGE},m.prototype.isSilentMonitor=function(){return this.getMonitorStatus()===t.MonitoringMode.SILENT_MONITOR},m.prototype.getMonitorStatus=function(){return this._getData().monitorStatus};var v=function(e,t){f.call(this,e,t)};(v.prototype=Object.create(f.prototype)).constructor=v,v.prototype.getMediaType=function(){return t.MediaType.TASK},v.prototype.getMediaInfo=function(){var e=t.core.getAgentDataProvider().getContactData(this.contactId);return{contactId:this.contactId,initialContactId:e.initialContactId||this.contactId}},v.prototype.getMediaController=function(){return t.core.mediaFactory.get(this)};var y=function(e,t){f.call(this,e,t)};(y.prototype=Object.create(f.prototype)).constructor=y,y.prototype.getMediaType=function(){return t.MediaType.EMAIL},y.prototype._initMediaController=function(){};var b=function(e){t.Connection.call(this,e.contactId,e.connectionId),this.connectionData=e};(b.prototype=Object.create(f.prototype)).constructor=b,b.prototype._getData=function(){return this.connectionData},b.prototype._initMediaController=function(){};var E=function(e){var t=e||{};this.endpointARN=t.endpointId||t.endpointARN||null,this.endpointId=this.endpointARN,this.type=t.type||null,this.name=t.name||null,this.phoneNumber=t.phoneNumber||null,this.agentLogin=t.agentLogin||null,this.queue=t.queue||null};E.prototype.stripPhoneNumber=function(){return this.phoneNumber?this.phoneNumber.replace(/sip:([^@]*)@.*/,"$1"):""},E.byPhoneNumber=function(e,n){return new E({type:t.EndpointType.PHONE_NUMBER,phoneNumber:e,name:n||null})};var S=function(e,t,n){this.errorType=e,this.errorMessage=t,this.endPointUrl=n};S.prototype.getErrorType=function(){return this.errorType},S.prototype.getErrorMessage=function(){return this.errorMessage},S.prototype.getEndPointUrl=function(){return this.endPointUrl},t.agent=function(e){var n=t.core.getEventBus().subscribe(t.AgentEvents.INIT,e);return t.agent.initialized&&e(new t.Agent),n},t.agent.initialized=!1,t.contact=function(e){return t.core.getEventBus().subscribe(t.ContactEvents.INIT,e)},t.onWebsocketInitFailure=function(e){var n=t.core.getEventBus().subscribe(t.WebSocketEvents.INIT_FAILURE,e);return t.webSocketInitFailed&&e(),n},t.ifMaster=function(e,n,r,o){if(t.assertNotNull(e,"A topic must be provided."),t.assertNotNull(n,"A true callback must be provided."),!t.core.masterClient)return t.getLog().warn("We can't be the master for topic '%s' because there is no master client!",e).sendInternalLogToServer(),void(r&&r());t.core.getMasterClient().call(t.MasterMethods.CHECK_MASTER,{topic:e,shouldNotBecomeMasterIfNone:o},{success:function(e){e.isMaster?n():r&&r()}})},t.becomeMaster=function(e,n,r){t.assertNotNull(e,"A topic must be provided."),t.core.masterClient?t.core.getMasterClient().call(t.MasterMethods.BECOME_MASTER,{topic:e},{success:function(){n&&n()}}):(t.getLog().warn("We can't be the master for topic '%s' because there is no master client!",e),r&&r())},t.Agent=s,t.AgentSnapshot=c,t.Contact=p,t.ContactSnapshot=d,t.Connection=g,t.BaseConnection=f,t.VoiceConnection=g,t.ChatConnection=m,t.TaskConnection=v,t.EmailConnection=y,t.ConnectionSnapshot=b,t.Endpoint=E,t.Address=E,t.SoftphoneError=S,t.VoiceId=h,t.QuickResponses=o}()},167:(e,t,n)=>{var r;function o(e){return o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},o(e)}!function e(t,n,r){function o(a,s){if(!n[a]){if(!t[a]){if(i)return i(a,!0);var c=new Error("Cannot find module '"+a+"'");throw c.code="MODULE_NOT_FOUND",c}var u=n[a]={exports:{}};t[a][0].call(u.exports,(function(e){return o(t[a][1][e]||e)}),u,u.exports,e,t,n,r)}return n[a].exports}for(var i=void 0,a=0;a<r.length;a++)o(r[a]);return o}({1:[function(e,t,n){t.exports={version:"2.0",metadata:{apiVersion:"2014-06-30",endpointPrefix:"cognito-identity",jsonVersion:"1.1",protocol:"json",serviceFullName:"Amazon Cognito Identity",serviceId:"Cognito Identity",signatureVersion:"v4",targetPrefix:"AWSCognitoIdentityService",uid:"cognito-identity-2014-06-30"},operations:{CreateIdentityPool:{input:{type:"structure",required:["IdentityPoolName","AllowUnauthenticatedIdentities"],members:{IdentityPoolName:{},AllowUnauthenticatedIdentities:{type:"boolean"},AllowClassicFlow:{type:"boolean"},SupportedLoginProviders:{shape:"S5"},DeveloperProviderName:{},OpenIdConnectProviderARNs:{shape:"S9"},CognitoIdentityProviders:{shape:"Sb"},SamlProviderARNs:{shape:"Sg"},IdentityPoolTags:{shape:"Sh"}}},output:{shape:"Sk"}},DeleteIdentities:{input:{type:"structure",required:["IdentityIdsToDelete"],members:{IdentityIdsToDelete:{type:"list",member:{}}}},output:{type:"structure",members:{UnprocessedIdentityIds:{type:"list",member:{type:"structure",members:{IdentityId:{},ErrorCode:{}}}}}}},DeleteIdentityPool:{input:{type:"structure",required:["IdentityPoolId"],members:{IdentityPoolId:{}}}},DescribeIdentity:{input:{type:"structure",required:["IdentityId"],members:{IdentityId:{}}},output:{shape:"Sv"}},DescribeIdentityPool:{input:{type:"structure",required:["IdentityPoolId"],members:{IdentityPoolId:{}}},output:{shape:"Sk"}},GetCredentialsForIdentity:{input:{type:"structure",required:["IdentityId"],members:{IdentityId:{},Logins:{shape:"S10"},CustomRoleArn:{}}},output:{type:"structure",members:{IdentityId:{},Credentials:{type:"structure",members:{AccessKeyId:{},SecretKey:{},SessionToken:{},Expiration:{type:"timestamp"}}}}},authtype:"none"},GetId:{input:{type:"structure",required:["IdentityPoolId"],members:{AccountId:{},IdentityPoolId:{},Logins:{shape:"S10"}}},output:{type:"structure",members:{IdentityId:{}}},authtype:"none"},GetIdentityPoolRoles:{input:{type:"structure",required:["IdentityPoolId"],members:{IdentityPoolId:{}}},output:{type:"structure",members:{IdentityPoolId:{},Roles:{shape:"S1c"},RoleMappings:{shape:"S1e"}}}},GetOpenIdToken:{input:{type:"structure",required:["IdentityId"],members:{IdentityId:{},Logins:{shape:"S10"}}},output:{type:"structure",members:{IdentityId:{},Token:{}}},authtype:"none"},GetOpenIdTokenForDeveloperIdentity:{input:{type:"structure",required:["IdentityPoolId","Logins"],members:{IdentityPoolId:{},IdentityId:{},Logins:{shape:"S10"},PrincipalTags:{shape:"S1s"},TokenDuration:{type:"long"}}},output:{type:"structure",members:{IdentityId:{},Token:{}}}},GetPrincipalTagAttributeMap:{input:{type:"structure",required:["IdentityPoolId","IdentityProviderName"],members:{IdentityPoolId:{},IdentityProviderName:{}}},output:{type:"structure",members:{IdentityPoolId:{},IdentityProviderName:{},UseDefaults:{type:"boolean"},PrincipalTags:{shape:"S1s"}}}},ListIdentities:{input:{type:"structure",required:["IdentityPoolId","MaxResults"],members:{IdentityPoolId:{},MaxResults:{type:"integer"},NextToken:{},HideDisabled:{type:"boolean"}}},output:{type:"structure",members:{IdentityPoolId:{},Identities:{type:"list",member:{shape:"Sv"}},NextToken:{}}}},ListIdentityPools:{input:{type:"structure",required:["MaxResults"],members:{MaxResults:{type:"integer"},NextToken:{}}},output:{type:"structure",members:{IdentityPools:{type:"list",member:{type:"structure",members:{IdentityPoolId:{},IdentityPoolName:{}}}},NextToken:{}}}},ListTagsForResource:{input:{type:"structure",required:["ResourceArn"],members:{ResourceArn:{}}},output:{type:"structure",members:{Tags:{shape:"Sh"}}}},LookupDeveloperIdentity:{input:{type:"structure",required:["IdentityPoolId"],members:{IdentityPoolId:{},IdentityId:{},DeveloperUserIdentifier:{},MaxResults:{type:"integer"},NextToken:{}}},output:{type:"structure",members:{IdentityId:{},DeveloperUserIdentifierList:{type:"list",member:{}},NextToken:{}}}},MergeDeveloperIdentities:{input:{type:"structure",required:["SourceUserIdentifier","DestinationUserIdentifier","DeveloperProviderName","IdentityPoolId"],members:{SourceUserIdentifier:{},DestinationUserIdentifier:{},DeveloperProviderName:{},IdentityPoolId:{}}},output:{type:"structure",members:{IdentityId:{}}}},SetIdentityPoolRoles:{input:{type:"structure",required:["IdentityPoolId","Roles"],members:{IdentityPoolId:{},Roles:{shape:"S1c"},RoleMappings:{shape:"S1e"}}}},SetPrincipalTagAttributeMap:{input:{type:"structure",required:["IdentityPoolId","IdentityProviderName"],members:{IdentityPoolId:{},IdentityProviderName:{},UseDefaults:{type:"boolean"},PrincipalTags:{shape:"S1s"}}},output:{type:"structure",members:{IdentityPoolId:{},IdentityProviderName:{},UseDefaults:{type:"boolean"},PrincipalTags:{shape:"S1s"}}}},TagResource:{input:{type:"structure",required:["ResourceArn","Tags"],members:{ResourceArn:{},Tags:{shape:"Sh"}}},output:{type:"structure",members:{}}},UnlinkDeveloperIdentity:{input:{type:"structure",required:["IdentityId","IdentityPoolId","DeveloperProviderName","DeveloperUserIdentifier"],members:{IdentityId:{},IdentityPoolId:{},DeveloperProviderName:{},DeveloperUserIdentifier:{}}}},UnlinkIdentity:{input:{type:"structure",required:["IdentityId","Logins","LoginsToRemove"],members:{IdentityId:{},Logins:{shape:"S10"},LoginsToRemove:{shape:"Sw"}}},authtype:"none"},UntagResource:{input:{type:"structure",required:["ResourceArn","TagKeys"],members:{ResourceArn:{},TagKeys:{type:"list",member:{}}}},output:{type:"structure",members:{}}},UpdateIdentityPool:{input:{shape:"Sk"},output:{shape:"Sk"}}},shapes:{S5:{type:"map",key:{},value:{}},S9:{type:"list",member:{}},Sb:{type:"list",member:{type:"structure",members:{ProviderName:{},ClientId:{},ServerSideTokenCheck:{type:"boolean"}}}},Sg:{type:"list",member:{}},Sh:{type:"map",key:{},value:{}},Sk:{type:"structure",required:["IdentityPoolId","IdentityPoolName","AllowUnauthenticatedIdentities"],members:{IdentityPoolId:{},IdentityPoolName:{},AllowUnauthenticatedIdentities:{type:"boolean"},AllowClassicFlow:{type:"boolean"},SupportedLoginProviders:{shape:"S5"},DeveloperProviderName:{},OpenIdConnectProviderARNs:{shape:"S9"},CognitoIdentityProviders:{shape:"Sb"},SamlProviderARNs:{shape:"Sg"},IdentityPoolTags:{shape:"Sh"}}},Sv:{type:"structure",members:{IdentityId:{},Logins:{shape:"Sw"},CreationDate:{type:"timestamp"},LastModifiedDate:{type:"timestamp"}}},Sw:{type:"list",member:{}},S10:{type:"map",key:{},value:{}},S1c:{type:"map",key:{},value:{}},S1e:{type:"map",key:{},value:{type:"structure",required:["Type"],members:{Type:{},AmbiguousRoleResolution:{},RulesConfiguration:{type:"structure",required:["Rules"],members:{Rules:{type:"list",member:{type:"structure",required:["Claim","MatchType","Value","RoleARN"],members:{Claim:{},MatchType:{},Value:{},RoleARN:{}}}}}}}}},S1s:{type:"map",key:{},value:{}}}}},{}],2:[function(e,t,n){t.exports={pagination:{ListIdentityPools:{input_token:"NextToken",limit_key:"MaxResults",output_token:"NextToken",result_key:"IdentityPools"}}}},{}],3:[function(e,t,n){t.exports={version:"2.0",metadata:{apiVersion:"2017-02-15",endpointPrefix:"connect",jsonVersion:"1.0",protocol:"json",serviceAbbreviation:"Connect",serviceFullName:"AmazonConnectCTIService",signatureVersion:"",targetPrefix:"AmazonConnectCTIService",uid:"connect-2017-02-15"},operations:{AcceptContact:{input:{type:"structure",required:["authentication","contactId"],members:{authentication:{shape:"S2"},contactId:{}}},output:{type:"structure",members:{}}},ClearContact:{input:{type:"structure",required:["contactId"],members:{contactId:{}}},output:{type:"structure",members:{}}},CompleteContact:{input:{type:"structure",required:["contactId"],members:{contactId:{}}},output:{type:"structure",members:{}}},ConferenceConnections:{input:{type:"structure",required:["authentication","contactId"],members:{authentication:{shape:"S2"},contactId:{}}},output:{type:"structure",members:{}}},CreateAdditionalConnection:{input:{type:"structure",required:["authentication","contactId","endpoint"],members:{authentication:{shape:"S2"},contactId:{},endpoint:{shape:"Se"}}},output:{type:"structure",members:{}}},CreateOutboundContact:{input:{type:"structure",required:["authentication","endpoint"],members:{authentication:{shape:"S2"},endpoint:{shape:"Se"},queueARN:{},relatedContactId:{}}},output:{type:"structure",members:{}}},CreateTaskContact:{input:{type:"structure",required:["endpoint","name"],members:{endpoint:{shape:"Se"},previousContactId:{},name:{},description:{},references:{shape:"St"},idempotencyToken:{},scheduledTime:{type:"long"},relatedContactId:{}}},output:{type:"structure",members:{contactId:{}}}},CreateTransport:{input:{type:"structure",required:["transportType","authentication"],members:{transportType:{},participantId:{},contactId:{},softphoneClientId:{},authentication:{shape:"S2"}}},output:{type:"structure",members:{webSocketTransport:{type:"structure",required:["url","transportLifeTimeInSeconds"],members:{url:{},transportLifeTimeInSeconds:{type:"long"},expiry:{}}},chatTokenTransport:{type:"structure",required:["participantToken","expiry"],members:{participantToken:{},expiry:{}}},softphoneTransport:{type:"structure",required:["softphoneMediaConnections"],members:{softphoneMediaConnections:{type:"list",member:{type:"structure",required:["username","credential","urls"],members:{username:{},credential:{},urls:{type:"list",member:{}}}}}}},agentDiscoveryTransport:{type:"structure",required:["presignedUrl"],members:{presignedUrl:{}}},webRTCTransport:{type:"structure",required:["meeting","attendee"],members:{meeting:{type:"structure",members:{meetingId:{},mediaRegion:{},mediaPlacement:{type:"structure",members:{audioHostUrl:{},audioFallbackUrl:{},signalingUrl:{},turnControlUrl:{},eventIngestionUrl:{}}},meetingFeatures:{type:"structure",members:{audio:{type:"structure",members:{echoReduction:{}}}}}}},attendee:{type:"structure",members:{attendeeId:{},joinToken:{type:"string",sensitive:!0}}}}}}}},DestroyConnection:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},GetAgentConfiguration:{input:{type:"structure",required:["authentication"],members:{authentication:{shape:"S2"}}},output:{type:"structure",required:["configuration"],members:{configuration:{shape:"S1v"}}}},GetAgentPermissions:{input:{type:"structure",required:["authentication"],members:{authentication:{shape:"S2"},nextToken:{},maxResults:{type:"integer"}}},output:{type:"structure",required:["permissions"],members:{permissions:{type:"list",member:{}},nextToken:{}}}},GetAgentSnapshot:{input:{type:"structure",required:["authentication"],members:{authentication:{shape:"S2"},nextToken:{},timeout:{type:"long"}}},output:{type:"structure",required:["snapshot","nextToken"],members:{snapshot:{type:"structure",required:["state","contacts","snapshotTimestamp"],members:{state:{shape:"S2e"},nextState:{shape:"S2e"},agentAvailabilityState:{type:"structure",members:{state:{},timeStamp:{type:"timestamp"}}},contacts:{type:"list",member:{type:"structure",required:["contactId","type","state","connections","attributes"],members:{contactId:{},initialContactId:{},relatedContactId:{},contactAssociationId:{},type:{},state:{type:"structure",required:["type","timestamp"],members:{type:{},timestamp:{type:"timestamp"}}},queue:{shape:"Sl"},queueTimestamp:{type:"timestamp"},connections:{type:"list",member:{type:"structure",required:["connectionId","state","type","initial"],members:{connectionId:{},endpoint:{shape:"Se"},state:{type:"structure",required:["type","timestamp"],members:{type:{},timestamp:{type:"timestamp"}}},type:{},initial:{type:"boolean"},softphoneMediaInfo:{type:"structure",members:{callType:{},autoAccept:{type:"boolean"},mediaLegContextToken:{},callContextToken:{},callConfigJson:{}}},chatMediaInfo:{type:"structure",members:{chatAutoAccept:{type:"boolean"},connectionData:{},customerName:{}}},monitoringInfo:{type:"structure",members:{agent:{type:"structure",members:{agentName:{}}},joinTimeStamp:{type:"timestamp"}}},mute:{type:"boolean"},forcedMute:{type:"boolean"},quickConnectName:{},monitorCapabilities:{type:"list",member:{}},monitorStatus:{},capabilities:{type:"structure",members:{Video:{}}}}}},attributes:{type:"map",key:{},value:{type:"structure",required:["name"],members:{name:{},value:{}}}},contactDuration:{},name:{},description:{},references:{shape:"St"},initiationMethod:{},contactFeatures:{type:"structure",members:{attachmentsEnabled:{type:"boolean"},messagingMarkdownEnabled:{type:"boolean"},multiPartyConferenceEnabled:{type:"boolean"},screenRecordingEnabled:{type:"boolean"},screenRecordingState:{},screenRecordingConfig:{type:"structure",members:{screenRecordingEnabled:{type:"boolean"},screenRecordingState:{}}}}},channelContext:{type:"structure",members:{scheduledTime:{type:"long"},taskTemplateId:{},taskTemplateVersion:{type:"integer"}}},segmentAttributes:{type:"map",key:{},value:{type:"structure",members:{ValueString:{}}}},customerEndpoint:{shape:"Se"},connectSystemEndpoint:{shape:"Se"},languageCode:{},emailRecipients:{type:"structure",members:{toList:{type:"list",member:{shape:"S3i"}},ccList:{type:"list",member:{shape:"S3i"}},fromRecipient:{shape:"S3i"}}}}}},snapshotTimestamp:{type:"timestamp"}}},nextToken:{}}}},GetAgentStates:{input:{type:"structure",required:["authentication"],members:{authentication:{shape:"S2"},nextToken:{},maxResults:{type:"integer"}}},output:{type:"structure",required:["states"],members:{states:{type:"list",member:{shape:"S2e"}},nextToken:{}}}},GetDialableCountryCodes:{input:{type:"structure",required:["authentication"],members:{authentication:{shape:"S2"},nextToken:{},maxResults:{type:"integer"}}},output:{type:"structure",required:["countryCodes"],members:{countryCodes:{type:"list",member:{}},nextToken:{}}}},GetEndpoints:{input:{type:"structure",required:["authentication","queueARNs"],members:{authentication:{shape:"S2"},queueARNs:{type:"list",member:{}},nextToken:{},maxResults:{type:"integer"}}},output:{type:"structure",members:{endpoints:{type:"list",member:{shape:"Se"}},nextToken:{}}}},GetNewAuthToken:{input:{type:"structure",required:["authentication","refreshToken"],members:{authentication:{shape:"S2"},refreshToken:{}}},output:{type:"structure",members:{newAuthToken:{},expirationDateTime:{type:"timestamp"}}}},GetRoutingProfileQueues:{input:{type:"structure",required:["authentication","routingProfileARN"],members:{authentication:{shape:"S2"},routingProfileARN:{},nextToken:{},maxResults:{type:"integer"}}},output:{type:"structure",required:["queues"],members:{queues:{type:"list",member:{shape:"Sl"}},nextToken:{}}}},HoldConnection:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},MuteParticipant:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},NotifyContactIssue:{input:{type:"structure",required:["authentication","contactId"],members:{authentication:{shape:"S2"},contactId:{},issueCode:{},description:{},clientLogs:{}}},output:{type:"structure",members:{}}},PauseContact:{input:{type:"structure",required:["contactId"],members:{contactId:{}}},output:{type:"structure",members:{}}},PutAgentState:{input:{type:"structure",required:["authentication","state"],members:{authentication:{shape:"S2"},state:{shape:"S2e"},enqueueNextState:{type:"boolean"}}},output:{type:"structure",members:{}}},RejectContact:{input:{type:"structure",required:["contactId"],members:{contactId:{}}},output:{type:"structure",members:{}}},ResumeConnection:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},ResumeContact:{input:{type:"structure",required:["contactId"],members:{contactId:{}}},output:{type:"structure",members:{}}},SendClientLogs:{input:{type:"structure",required:["authentication","logEvents"],members:{authentication:{shape:"S2"},logEvents:{type:"list",member:{type:"structure",members:{timestamp:{type:"timestamp"},component:{},message:{}}}}}},output:{type:"structure",members:{}}},SendDigits:{input:{type:"structure",required:["authentication","contactId","connectionId","digits"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{},digits:{}}},output:{type:"structure",members:{}}},SendSoftphoneCallMetrics:{input:{type:"structure",required:["authentication","contactId","softphoneStreamStatistics"],members:{authentication:{shape:"S2"},contactId:{},ccpVersion:{},softphoneStreamStatistics:{shape:"S4p"}}},output:{type:"structure",members:{}}},SendSoftphoneCallReport:{input:{type:"structure",required:["authentication","contactId","report"],members:{authentication:{shape:"S2"},contactId:{},ccpVersion:{},report:{type:"structure",members:{callStartTime:{type:"timestamp"},callEndTime:{type:"timestamp"},softphoneStreamStatistics:{shape:"S4p"},gumTimeMillis:{type:"long"},initializationTimeMillis:{type:"long"},iceCollectionTimeMillis:{type:"long"},signallingConnectTimeMillis:{type:"long"},handshakeTimeMillis:{type:"long"},preTalkTimeMillis:{type:"long"},talkTimeMillis:{type:"long"},cleanupTimeMillis:{type:"long"},iceCollectionFailure:{type:"boolean"},signallingConnectionFailure:{type:"boolean"},handshakeFailure:{type:"boolean"},gumOtherFailure:{type:"boolean"},gumTimeoutFailure:{type:"boolean"},createOfferFailure:{type:"boolean"},setLocalDescriptionFailure:{type:"boolean"},userBusyFailure:{type:"boolean"},invalidRemoteSDPFailure:{type:"boolean"},noRemoteIceCandidateFailure:{type:"boolean"},setRemoteDescriptionFailure:{type:"boolean"}}}}},output:{type:"structure",members:{}}},ToggleActiveConnections:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},UnmuteParticipant:{input:{type:"structure",required:["authentication","contactId","connectionId"],members:{authentication:{shape:"S2"},contactId:{},connectionId:{}}},output:{type:"structure",members:{}}},UpdateAgentConfiguration:{input:{type:"structure",required:["authentication","configuration"],members:{authentication:{shape:"S2"},configuration:{shape:"S1v"}}},output:{type:"structure",members:{}}},UpdateMonitorParticipantState:{input:{type:"structure",required:["contactId","targetMonitorMode"],members:{contactId:{},targetMonitorMode:{}}},output:{type:"structure",members:{}}}},shapes:{S2:{type:"structure",members:{agentARN:{},authToken:{}}},Se:{type:"structure",required:["type"],members:{endpointARN:{},type:{},name:{},displayName:{},phoneNumber:{},agentLogin:{},queue:{shape:"Sl"},emailAddress:{}}},Sl:{type:"structure",members:{queueARN:{},name:{}}},St:{type:"map",key:{},value:{type:"structure",required:["type"],members:{value:{},type:{},arn:{},status:{},statusReason:{}}}},S1v:{type:"structure",required:["name","softphoneEnabled","softphoneAutoAccept","extension","routingProfile"],members:{name:{},username:{},softphoneEnabled:{type:"boolean"},softphoneAutoAccept:{type:"boolean"},extension:{},routingProfile:{type:"structure",members:{name:{},routingProfileARN:{},defaultOutboundQueue:{shape:"Sl"},channelConcurrencyMap:{type:"map",key:{},value:{type:"long"}}}},agentPreferences:{type:"map",key:{},value:{}},agentARN:{}}},S2e:{type:"structure",required:["type","name"],members:{agentStateARN:{},type:{},name:{},startTimestamp:{type:"timestamp"}}},S3i:{type:"structure",members:{address:{},displayName:{}}},S4p:{type:"list",member:{type:"structure",members:{timestamp:{type:"timestamp"},softphoneStreamType:{},packetCount:{type:"long"},packetsLost:{type:"long"},audioLevel:{type:"double"},jitterBufferMillis:{type:"long"},roundTripTimeMillis:{type:"long"}}}}}}},{}],4:[function(e,t,n){t.exports={acm:{name:"ACM",cors:!0},apigateway:{name:"APIGateway",cors:!0},applicationautoscaling:{prefix:"application-autoscaling",name:"ApplicationAutoScaling",cors:!0},appstream:{name:"AppStream"},autoscaling:{name:"AutoScaling",cors:!0},batch:{name:"Batch"},budgets:{name:"Budgets"},clouddirectory:{name:"CloudDirectory",versions:["2016-05-10*"]},cloudformation:{name:"CloudFormation",cors:!0},cloudfront:{name:"CloudFront",versions:["2013-05-12*","2013-11-11*","2014-05-31*","2014-10-21*","2014-11-06*","2015-04-17*","2015-07-27*","2015-09-17*","2016-01-13*","2016-01-28*","2016-08-01*","2016-08-20*","2016-09-07*","2016-09-29*","2016-11-25*","2017-03-25*","2017-10-30*","2018-06-18*","2018-11-05*","2019-03-26*"],cors:!0},cloudhsm:{name:"CloudHSM",cors:!0},cloudsearch:{name:"CloudSearch"},cloudsearchdomain:{name:"CloudSearchDomain"},cloudtrail:{name:"CloudTrail",cors:!0},cloudwatch:{prefix:"monitoring",name:"CloudWatch",cors:!0},cloudwatchevents:{prefix:"events",name:"CloudWatchEvents",versions:["2014-02-03*"],cors:!0},cloudwatchlogs:{prefix:"logs",name:"CloudWatchLogs",cors:!0},codebuild:{name:"CodeBuild",cors:!0},codecommit:{name:"CodeCommit",cors:!0},codedeploy:{name:"CodeDeploy",cors:!0},codepipeline:{name:"CodePipeline",cors:!0},cognitoidentity:{prefix:"cognito-identity",name:"CognitoIdentity",cors:!0},cognitoidentityserviceprovider:{prefix:"cognito-idp",name:"CognitoIdentityServiceProvider",cors:!0},cognitosync:{prefix:"cognito-sync",name:"CognitoSync",cors:!0},configservice:{prefix:"config",name:"ConfigService",cors:!0},cur:{name:"CUR",cors:!0},datapipeline:{name:"DataPipeline"},devicefarm:{name:"DeviceFarm",cors:!0},directconnect:{name:"DirectConnect",cors:!0},directoryservice:{prefix:"ds",name:"DirectoryService"},discovery:{name:"Discovery"},dms:{name:"DMS"},dynamodb:{name:"DynamoDB",cors:!0},dynamodbstreams:{prefix:"streams.dynamodb",name:"DynamoDBStreams",cors:!0},ec2:{name:"EC2",versions:["2013-06-15*","2013-10-15*","2014-02-01*","2014-05-01*","2014-06-15*","2014-09-01*","2014-10-01*","2015-03-01*","2015-04-15*","2015-10-01*","2016-04-01*","2016-09-15*"],cors:!0},ecr:{name:"ECR",cors:!0},ecs:{name:"ECS",cors:!0},efs:{prefix:"elasticfilesystem",name:"EFS",cors:!0},elasticache:{name:"ElastiCache",versions:["2012-11-15*","2014-03-24*","2014-07-15*","2014-09-30*"],cors:!0},elasticbeanstalk:{name:"ElasticBeanstalk",cors:!0},elb:{prefix:"elasticloadbalancing",name:"ELB",cors:!0},elbv2:{prefix:"elasticloadbalancingv2",name:"ELBv2",cors:!0},emr:{prefix:"elasticmapreduce",name:"EMR",cors:!0},es:{name:"ES"},elastictranscoder:{name:"ElasticTranscoder",cors:!0},firehose:{name:"Firehose",cors:!0},gamelift:{name:"GameLift",cors:!0},glacier:{name:"Glacier"},health:{name:"Health"},iam:{name:"IAM",cors:!0},importexport:{name:"ImportExport"},inspector:{name:"Inspector",versions:["2015-08-18*"],cors:!0},iot:{name:"Iot",cors:!0},iotdata:{prefix:"iot-data",name:"IotData",cors:!0},kinesis:{name:"Kinesis",cors:!0},kinesisanalytics:{name:"KinesisAnalytics"},kms:{name:"KMS",cors:!0},lambda:{name:"Lambda",cors:!0},lexruntime:{prefix:"runtime.lex",name:"LexRuntime",cors:!0},lightsail:{name:"Lightsail"},machinelearning:{name:"MachineLearning",cors:!0},marketplacecommerceanalytics:{name:"MarketplaceCommerceAnalytics",cors:!0},marketplacemetering:{prefix:"meteringmarketplace",name:"MarketplaceMetering"},mturk:{prefix:"mturk-requester",name:"MTurk",cors:!0},mobileanalytics:{name:"MobileAnalytics",cors:!0},opsworks:{name:"OpsWorks",cors:!0},opsworkscm:{name:"OpsWorksCM"},organizations:{name:"Organizations"},pinpoint:{name:"Pinpoint"},polly:{name:"Polly",cors:!0},rds:{name:"RDS",versions:["2014-09-01*"],cors:!0},redshift:{name:"Redshift",cors:!0},rekognition:{name:"Rekognition",cors:!0},resourcegroupstaggingapi:{name:"ResourceGroupsTaggingAPI"},route53:{name:"Route53",cors:!0},route53domains:{name:"Route53Domains",cors:!0},s3:{name:"S3",dualstackAvailable:!0,cors:!0},s3control:{name:"S3Control",dualstackAvailable:!0,xmlNoDefaultLists:!0},servicecatalog:{name:"ServiceCatalog",cors:!0},ses:{prefix:"email",name:"SES",cors:!0},shield:{name:"Shield"},simpledb:{prefix:"sdb",name:"SimpleDB"},sms:{name:"SMS"},snowball:{name:"Snowball"},sns:{name:"SNS",cors:!0},sqs:{name:"SQS",cors:!0},ssm:{name:"SSM",cors:!0},storagegateway:{name:"StorageGateway",cors:!0},stepfunctions:{prefix:"states",name:"StepFunctions"},sts:{name:"STS",cors:!0},support:{name:"Support"},swf:{name:"SWF"},xray:{name:"XRay",cors:!0},waf:{name:"WAF",cors:!0},wafregional:{prefix:"waf-regional",name:"WAFRegional"},workdocs:{name:"WorkDocs",cors:!0},workspaces:{name:"WorkSpaces"},codestar:{name:"CodeStar"},lexmodelbuildingservice:{prefix:"lex-models",name:"LexModelBuildingService",cors:!0},marketplaceentitlementservice:{prefix:"entitlement.marketplace",name:"MarketplaceEntitlementService"},athena:{name:"Athena",cors:!0},greengrass:{name:"Greengrass"},dax:{name:"DAX"},migrationhub:{prefix:"AWSMigrationHub",name:"MigrationHub"},cloudhsmv2:{name:"CloudHSMV2",cors:!0},glue:{name:"Glue"},mobile:{name:"Mobile"},pricing:{name:"Pricing",cors:!0},costexplorer:{prefix:"ce",name:"CostExplorer",cors:!0},mediaconvert:{name:"MediaConvert"},medialive:{name:"MediaLive"},mediapackage:{name:"MediaPackage"},mediastore:{name:"MediaStore"},mediastoredata:{prefix:"mediastore-data",name:"MediaStoreData",cors:!0},appsync:{name:"AppSync"},guardduty:{name:"GuardDuty"},mq:{name:"MQ"},comprehend:{name:"Comprehend",cors:!0},iotjobsdataplane:{prefix:"iot-jobs-data",name:"IoTJobsDataPlane"},kinesisvideoarchivedmedia:{prefix:"kinesis-video-archived-media",name:"KinesisVideoArchivedMedia",cors:!0},kinesisvideomedia:{prefix:"kinesis-video-media",name:"KinesisVideoMedia",cors:!0},kinesisvideo:{name:"KinesisVideo",cors:!0},sagemakerruntime:{prefix:"runtime.sagemaker",name:"SageMakerRuntime"},sagemaker:{name:"SageMaker"},translate:{name:"Translate",cors:!0},resourcegroups:{prefix:"resource-groups",name:"ResourceGroups",cors:!0},alexaforbusiness:{name:"AlexaForBusiness"},cloud9:{name:"Cloud9"},serverlessapplicationrepository:{prefix:"serverlessrepo",name:"ServerlessApplicationRepository"},servicediscovery:{name:"ServiceDiscovery"},workmail:{name:"WorkMail"},autoscalingplans:{prefix:"autoscaling-plans",name:"AutoScalingPlans"},transcribeservice:{prefix:"transcribe",name:"TranscribeService"},connect:{name:"Connect",cors:!0},acmpca:{prefix:"acm-pca",name:"ACMPCA"},fms:{name:"FMS"},secretsmanager:{name:"SecretsManager",cors:!0},iotanalytics:{name:"IoTAnalytics",cors:!0},iot1clickdevicesservice:{prefix:"iot1click-devices",name:"IoT1ClickDevicesService"},iot1clickprojects:{prefix:"iot1click-projects",name:"IoT1ClickProjects"},pi:{name:"PI"},neptune:{name:"Neptune"},mediatailor:{name:"MediaTailor"},eks:{name:"EKS"},dlm:{name:"DLM"},signer:{name:"Signer"},chime:{name:"Chime"},pinpointemail:{prefix:"pinpoint-email",name:"PinpointEmail"},ram:{name:"RAM"},route53resolver:{name:"Route53Resolver"},pinpointsmsvoice:{prefix:"sms-voice",name:"PinpointSMSVoice"},quicksight:{name:"QuickSight"},rdsdataservice:{prefix:"rds-data",name:"RDSDataService"},amplify:{name:"Amplify"},datasync:{name:"DataSync"},robomaker:{name:"RoboMaker"},transfer:{name:"Transfer"},globalaccelerator:{name:"GlobalAccelerator"},comprehendmedical:{name:"ComprehendMedical",cors:!0},kinesisanalyticsv2:{name:"KinesisAnalyticsV2"},mediaconnect:{name:"MediaConnect"},fsx:{name:"FSx"},securityhub:{name:"SecurityHub"},appmesh:{name:"AppMesh",versions:["2018-10-01*"]},licensemanager:{prefix:"license-manager",name:"LicenseManager"},kafka:{name:"Kafka"},apigatewaymanagementapi:{name:"ApiGatewayManagementApi"},apigatewayv2:{name:"ApiGatewayV2"},docdb:{name:"DocDB"},backup:{name:"Backup"},worklink:{name:"WorkLink"},textract:{name:"Textract"},managedblockchain:{name:"ManagedBlockchain"},mediapackagevod:{prefix:"mediapackage-vod",name:"MediaPackageVod"},groundstation:{name:"GroundStation"},iotthingsgraph:{name:"IoTThingsGraph"},iotevents:{name:"IoTEvents"},ioteventsdata:{prefix:"iotevents-data",name:"IoTEventsData"},personalize:{name:"Personalize",cors:!0},personalizeevents:{prefix:"personalize-events",name:"PersonalizeEvents",cors:!0},personalizeruntime:{prefix:"personalize-runtime",name:"PersonalizeRuntime",cors:!0},applicationinsights:{prefix:"application-insights",name:"ApplicationInsights"},servicequotas:{prefix:"service-quotas",name:"ServiceQuotas"},ec2instanceconnect:{prefix:"ec2-instance-connect",name:"EC2InstanceConnect"},eventbridge:{name:"EventBridge"},lakeformation:{name:"LakeFormation"},forecastservice:{prefix:"forecast",name:"ForecastService",cors:!0},forecastqueryservice:{prefix:"forecastquery",name:"ForecastQueryService",cors:!0},qldb:{name:"QLDB"},qldbsession:{prefix:"qldb-session",name:"QLDBSession"},workmailmessageflow:{name:"WorkMailMessageFlow"},codestarnotifications:{prefix:"codestar-notifications",name:"CodeStarNotifications"},savingsplans:{name:"SavingsPlans"},sso:{name:"SSO"},ssooidc:{prefix:"sso-oidc",name:"SSOOIDC"},marketplacecatalog:{prefix:"marketplace-catalog",name:"MarketplaceCatalog",cors:!0},dataexchange:{name:"DataExchange"},sesv2:{name:"SESV2"},migrationhubconfig:{prefix:"migrationhub-config",name:"MigrationHubConfig"},connectparticipant:{name:"ConnectParticipant"},appconfig:{name:"AppConfig"},iotsecuretunneling:{name:"IoTSecureTunneling"},wafv2:{name:"WAFV2"},elasticinference:{prefix:"elastic-inference",name:"ElasticInference"},imagebuilder:{name:"Imagebuilder"},schemas:{name:"Schemas"},accessanalyzer:{name:"AccessAnalyzer"},codegurureviewer:{prefix:"codeguru-reviewer",name:"CodeGuruReviewer"},codeguruprofiler:{name:"CodeGuruProfiler"},computeoptimizer:{prefix:"compute-optimizer",name:"ComputeOptimizer"},frauddetector:{name:"FraudDetector"},kendra:{name:"Kendra"},networkmanager:{name:"NetworkManager"},outposts:{name:"Outposts"},augmentedairuntime:{prefix:"sagemaker-a2i-runtime",name:"AugmentedAIRuntime"},ebs:{name:"EBS"},kinesisvideosignalingchannels:{prefix:"kinesis-video-signaling",name:"KinesisVideoSignalingChannels",cors:!0},detective:{name:"Detective"},codestarconnections:{prefix:"codestar-connections",name:"CodeStarconnections"},synthetics:{name:"Synthetics"},iotsitewise:{name:"IoTSiteWise"},macie2:{name:"Macie2"},codeartifact:{name:"CodeArtifact"},honeycode:{name:"Honeycode"},ivs:{name:"IVS"},braket:{name:"Braket"},identitystore:{name:"IdentityStore"},appflow:{name:"Appflow"},redshiftdata:{prefix:"redshift-data",name:"RedshiftData"},ssoadmin:{prefix:"sso-admin",name:"SSOAdmin"},timestreamquery:{prefix:"timestream-query",name:"TimestreamQuery"},timestreamwrite:{prefix:"timestream-write",name:"TimestreamWrite"},s3outposts:{name:"S3Outposts"},databrew:{name:"DataBrew"},servicecatalogappregistry:{prefix:"servicecatalog-appregistry",name:"ServiceCatalogAppRegistry"},networkfirewall:{prefix:"network-firewall",name:"NetworkFirewall"},mwaa:{name:"MWAA"},amplifybackend:{name:"AmplifyBackend"},appintegrations:{name:"AppIntegrations"},connectcontactlens:{prefix:"connect-contact-lens",name:"ConnectContactLens"},devopsguru:{prefix:"devops-guru",name:"DevOpsGuru"},ecrpublic:{prefix:"ecr-public",name:"ECRPUBLIC"},lookoutvision:{name:"LookoutVision"},sagemakerfeaturestoreruntime:{prefix:"sagemaker-featurestore-runtime",name:"SageMakerFeatureStoreRuntime"},customerprofiles:{prefix:"customer-profiles",name:"CustomerProfiles"},auditmanager:{name:"AuditManager"},emrcontainers:{prefix:"emr-containers",name:"EMRcontainers"},healthlake:{name:"HealthLake"},sagemakeredge:{prefix:"sagemaker-edge",name:"SagemakerEdge"},amp:{name:"Amp",cors:!0},greengrassv2:{name:"GreengrassV2"},iotdeviceadvisor:{name:"IotDeviceAdvisor"},iotfleethub:{name:"IoTFleetHub"},iotwireless:{name:"IoTWireless"},location:{name:"Location",cors:!0},wellarchitected:{name:"WellArchitected"},lexmodelsv2:{prefix:"models.lex.v2",name:"LexModelsV2"},lexruntimev2:{prefix:"runtime.lex.v2",name:"LexRuntimeV2",cors:!0},fis:{name:"Fis"},lookoutmetrics:{name:"LookoutMetrics"},mgn:{name:"Mgn"},lookoutequipment:{name:"LookoutEquipment"},nimble:{name:"Nimble"},finspace:{name:"Finspace"},finspacedata:{prefix:"finspace-data",name:"Finspacedata"},ssmcontacts:{prefix:"ssm-contacts",name:"SSMContacts"},ssmincidents:{prefix:"ssm-incidents",name:"SSMIncidents"},applicationcostprofiler:{name:"ApplicationCostProfiler"},apprunner:{name:"AppRunner"},proton:{name:"Proton"},route53recoverycluster:{prefix:"route53-recovery-cluster",name:"Route53RecoveryCluster"},route53recoverycontrolconfig:{prefix:"route53-recovery-control-config",name:"Route53RecoveryControlConfig"},route53recoveryreadiness:{prefix:"route53-recovery-readiness",name:"Route53RecoveryReadiness"},chimesdkidentity:{prefix:"chime-sdk-identity",name:"ChimeSDKIdentity"},chimesdkmessaging:{prefix:"chime-sdk-messaging",name:"ChimeSDKMessaging"},snowdevicemanagement:{prefix:"snow-device-management",name:"SnowDeviceManagement"},memorydb:{name:"MemoryDB"},opensearch:{name:"OpenSearch"},kafkaconnect:{name:"KafkaConnect"},voiceid:{prefix:"voice-id",name:"VoiceID"},wisdom:{name:"Wisdom"},account:{name:"Account"},cloudcontrol:{name:"CloudControl"},grafana:{name:"Grafana"},panorama:{name:"Panorama"},chimesdkmeetings:{prefix:"chime-sdk-meetings",name:"ChimeSDKMeetings"},resiliencehub:{name:"Resiliencehub"},migrationhubstrategy:{name:"MigrationHubStrategy"},appconfigdata:{name:"AppConfigData"},drs:{name:"Drs"},migrationhubrefactorspaces:{prefix:"migration-hub-refactor-spaces",name:"MigrationHubRefactorSpaces"},evidently:{name:"Evidently"},inspector2:{name:"Inspector2"},rbin:{name:"Rbin"},rum:{name:"RUM"},backupgateway:{prefix:"backup-gateway",name:"BackupGateway"},iottwinmaker:{name:"IoTTwinMaker"},workspacesweb:{prefix:"workspaces-web",name:"WorkSpacesWeb"},amplifyuibuilder:{name:"AmplifyUIBuilder"},keyspaces:{name:"Keyspaces"},billingconductor:{name:"Billingconductor"},pinpointsmsvoicev2:{prefix:"pinpoint-sms-voice-v2",name:"PinpointSMSVoiceV2"},ivschat:{name:"Ivschat"},chimesdkmediapipelines:{prefix:"chime-sdk-media-pipelines",name:"ChimeSDKMediaPipelines"},emrserverless:{prefix:"emr-serverless",name:"EMRServerless"},m2:{name:"M2"},connectcampaigns:{name:"ConnectCampaigns"},redshiftserverless:{prefix:"redshift-serverless",name:"RedshiftServerless"},rolesanywhere:{name:"RolesAnywhere"},licensemanagerusersubscriptions:{prefix:"license-manager-user-subscriptions",name:"LicenseManagerUserSubscriptions"},backupstorage:{name:"BackupStorage"},privatenetworks:{name:"PrivateNetworks"},supportapp:{prefix:"support-app",name:"SupportApp"},controltower:{name:"ControlTower"},iotfleetwise:{name:"IoTFleetWise"},migrationhuborchestrator:{name:"MigrationHubOrchestrator"},connectcases:{name:"ConnectCases"},resourceexplorer2:{prefix:"resource-explorer-2",name:"ResourceExplorer2"},scheduler:{name:"Scheduler"},chimesdkvoice:{prefix:"chime-sdk-voice",name:"ChimeSDKVoice"},ssmsap:{prefix:"ssm-sap",name:"SsmSap"},oam:{name:"OAM"},arczonalshift:{prefix:"arc-zonal-shift",name:"ARCZonalShift"},omics:{name:"Omics"},opensearchserverless:{name:"OpenSearchServerless"},securitylake:{name:"SecurityLake"},simspaceweaver:{name:"SimSpaceWeaver"},docdbelastic:{prefix:"docdb-elastic",name:"DocDBElastic"},sagemakergeospatial:{prefix:"sagemaker-geospatial",name:"SageMakerGeospatial"},codecatalyst:{name:"CodeCatalyst"},pipes:{name:"Pipes"},sagemakermetrics:{prefix:"sagemaker-metrics",name:"SageMakerMetrics"},kinesisvideowebrtcstorage:{prefix:"kinesis-video-webrtc-storage",name:"KinesisVideoWebRTCStorage"},licensemanagerlinuxsubscriptions:{prefix:"license-manager-linux-subscriptions",name:"LicenseManagerLinuxSubscriptions"},kendraranking:{prefix:"kendra-ranking",name:"KendraRanking"},cleanrooms:{name:"CleanRooms"},cloudtraildata:{prefix:"cloudtrail-data",name:"CloudTrailData"},tnb:{name:"Tnb"},internetmonitor:{name:"InternetMonitor"},ivsrealtime:{prefix:"ivs-realtime",name:"IVSRealTime"},vpclattice:{prefix:"vpc-lattice",name:"VPCLattice"},osis:{name:"OSIS"},mediapackagev2:{name:"MediaPackageV2"},paymentcryptography:{prefix:"payment-cryptography",name:"PaymentCryptography"},paymentcryptographydata:{prefix:"payment-cryptography-data",name:"PaymentCryptographyData"},codegurusecurity:{prefix:"codeguru-security",name:"CodeGuruSecurity"},verifiedpermissions:{name:"VerifiedPermissions"},appfabric:{name:"AppFabric"},medicalimaging:{prefix:"medical-imaging",name:"MedicalImaging"},entityresolution:{name:"EntityResolution"},managedblockchainquery:{prefix:"managedblockchain-query",name:"ManagedBlockchainQuery"},neptunedata:{name:"Neptunedata"},pcaconnectorad:{prefix:"pca-connector-ad",name:"PcaConnectorAd"},bedrock:{name:"Bedrock"},bedrockruntime:{prefix:"bedrock-runtime",name:"BedrockRuntime"},datazone:{name:"DataZone"},launchwizard:{prefix:"launch-wizard",name:"LaunchWizard"},trustedadvisor:{name:"TrustedAdvisor"},inspectorscan:{prefix:"inspector-scan",name:"InspectorScan"},bcmdataexports:{prefix:"bcm-data-exports",name:"BCMDataExports"},costoptimizationhub:{prefix:"cost-optimization-hub",name:"CostOptimizationHub"},eksauth:{prefix:"eks-auth",name:"EKSAuth"},freetier:{name:"FreeTier"},repostspace:{name:"Repostspace"},workspacesthinclient:{prefix:"workspaces-thin-client",name:"WorkSpacesThinClient"},b2bi:{name:"B2bi"},bedrockagent:{prefix:"bedrock-agent",name:"BedrockAgent"},bedrockagentruntime:{prefix:"bedrock-agent-runtime",name:"BedrockAgentRuntime"},qbusiness:{name:"QBusiness"},qconnect:{name:"QConnect"},cleanroomsml:{name:"CleanRoomsML"},marketplaceagreement:{prefix:"marketplace-agreement",name:"MarketplaceAgreement"},marketplacedeployment:{prefix:"marketplace-deployment",name:"MarketplaceDeployment"},networkmonitor:{name:"NetworkMonitor"},supplychain:{name:"SupplyChain"},artifact:{name:"Artifact"},chatbot:{name:"Chatbot"},timestreaminfluxdb:{prefix:"timestream-influxdb",name:"TimestreamInfluxDB"},codeconnections:{name:"CodeConnections"}}},{}],5:[function(e,t,n){t.exports={version:"2.0",metadata:{apiVersion:"2011-06-15",endpointPrefix:"sts",globalEndpoint:"sts.amazonaws.com",protocol:"query",serviceAbbreviation:"AWS STS",serviceFullName:"AWS Security Token Service",serviceId:"STS",signatureVersion:"v4",uid:"sts-2011-06-15",xmlNamespace:"https://sts.amazonaws.com/doc/2011-06-15/"},operations:{AssumeRole:{input:{type:"structure",required:["RoleArn","RoleSessionName"],members:{RoleArn:{},RoleSessionName:{},PolicyArns:{shape:"S4"},Policy:{},DurationSeconds:{type:"integer"},Tags:{shape:"S8"},TransitiveTagKeys:{type:"list",member:{}},ExternalId:{},SerialNumber:{},TokenCode:{},SourceIdentity:{},ProvidedContexts:{type:"list",member:{type:"structure",members:{ProviderArn:{},ContextAssertion:{}}}}}},output:{resultWrapper:"AssumeRoleResult",type:"structure",members:{Credentials:{shape:"Sl"},AssumedRoleUser:{shape:"Sq"},PackedPolicySize:{type:"integer"},SourceIdentity:{}}}},AssumeRoleWithSAML:{input:{type:"structure",required:["RoleArn","PrincipalArn","SAMLAssertion"],members:{RoleArn:{},PrincipalArn:{},SAMLAssertion:{type:"string",sensitive:!0},PolicyArns:{shape:"S4"},Policy:{},DurationSeconds:{type:"integer"}}},output:{resultWrapper:"AssumeRoleWithSAMLResult",type:"structure",members:{Credentials:{shape:"Sl"},AssumedRoleUser:{shape:"Sq"},PackedPolicySize:{type:"integer"},Subject:{},SubjectType:{},Issuer:{},Audience:{},NameQualifier:{},SourceIdentity:{}}}},AssumeRoleWithWebIdentity:{input:{type:"structure",required:["RoleArn","RoleSessionName","WebIdentityToken"],members:{RoleArn:{},RoleSessionName:{},WebIdentityToken:{type:"string",sensitive:!0},ProviderId:{},PolicyArns:{shape:"S4"},Policy:{},DurationSeconds:{type:"integer"}}},output:{resultWrapper:"AssumeRoleWithWebIdentityResult",type:"structure",members:{Credentials:{shape:"Sl"},SubjectFromWebIdentityToken:{},AssumedRoleUser:{shape:"Sq"},PackedPolicySize:{type:"integer"},Provider:{},Audience:{},SourceIdentity:{}}}},DecodeAuthorizationMessage:{input:{type:"structure",required:["EncodedMessage"],members:{EncodedMessage:{}}},output:{resultWrapper:"DecodeAuthorizationMessageResult",type:"structure",members:{DecodedMessage:{}}}},GetAccessKeyInfo:{input:{type:"structure",required:["AccessKeyId"],members:{AccessKeyId:{}}},output:{resultWrapper:"GetAccessKeyInfoResult",type:"structure",members:{Account:{}}}},GetCallerIdentity:{input:{type:"structure",members:{}},output:{resultWrapper:"GetCallerIdentityResult",type:"structure",members:{UserId:{},Account:{},Arn:{}}}},GetFederationToken:{input:{type:"structure",required:["Name"],members:{Name:{},Policy:{},PolicyArns:{shape:"S4"},DurationSeconds:{type:"integer"},Tags:{shape:"S8"}}},output:{resultWrapper:"GetFederationTokenResult",type:"structure",members:{Credentials:{shape:"Sl"},FederatedUser:{type:"structure",required:["FederatedUserId","Arn"],members:{FederatedUserId:{},Arn:{}}},PackedPolicySize:{type:"integer"}}}},GetSessionToken:{input:{type:"structure",members:{DurationSeconds:{type:"integer"},SerialNumber:{},TokenCode:{}}},output:{resultWrapper:"GetSessionTokenResult",type:"structure",members:{Credentials:{shape:"Sl"}}}}},shapes:{S4:{type:"list",member:{type:"structure",members:{arn:{}}}},S8:{type:"list",member:{type:"structure",required:["Key","Value"],members:{Key:{},Value:{}}}},Sl:{type:"structure",required:["AccessKeyId","SecretAccessKey","SessionToken","Expiration"],members:{AccessKeyId:{},SecretAccessKey:{type:"string",sensitive:!0},SessionToken:{},Expiration:{type:"timestamp"}}},Sq:{type:"structure",required:["AssumedRoleId","Arn"],members:{AssumedRoleId:{},Arn:{}}}}}},{}],6:[function(e,t,n){t.exports={pagination:{}}},{}],7:[function(e,t,n){e("../lib/node_loader");var r=e("../lib/core"),o=r.Service,i=r.apiLoader;i.services.cognitoidentity={},r.CognitoIdentity=o.defineService("cognitoidentity",["2014-06-30"]),Object.defineProperty(i.services.cognitoidentity,"2014-06-30",{get:function(){var t=e("../apis/cognito-identity-2014-06-30.min.json");return t.paginators=e("../apis/cognito-identity-2014-06-30.paginators.json").pagination,t},enumerable:!0,configurable:!0}),t.exports=r.CognitoIdentity},{"../apis/cognito-identity-2014-06-30.min.json":1,"../apis/cognito-identity-2014-06-30.paginators.json":2,"../lib/core":19,"../lib/node_loader":16}],8:[function(e,t,n){e("../lib/node_loader");var r=e("../lib/core"),o=r.Service,i=r.apiLoader;i.services.sts={},r.STS=o.defineService("sts",["2011-06-15"]),e("../lib/services/sts"),Object.defineProperty(i.services.sts,"2011-06-15",{get:function(){var t=e("../apis/sts-2011-06-15.min.json");return t.paginators=e("../apis/sts-2011-06-15.paginators.json").pagination,t},enumerable:!0,configurable:!0}),t.exports=r.STS},{"../apis/sts-2011-06-15.min.json":5,"../apis/sts-2011-06-15.paginators.json":6,"../lib/core":19,"../lib/node_loader":16,"../lib/services/sts":63}],9:[function(e,t,n){function r(e,t){if(!r.services.hasOwnProperty(e))throw new Error("InvalidService: Failed to load api for "+e);return r.services[e][t]}r.services={},t.exports=r},{}],10:[function(e,t,n){var r=e("./browserHmac"),o=e("./browserMd5"),i=e("./browserSha1"),a=e("./browserSha256");t.exports={createHash:function(e){if("md5"===(e=e.toLowerCase()))return new o;if("sha256"===e)return new a;if("sha1"===e)return new i;throw new Error("Hash algorithm "+e+" is not supported in the browser SDK")},createHmac:function(e,t){if("md5"===(e=e.toLowerCase()))return new r(o,t);if("sha256"===e)return new r(a,t);if("sha1"===e)return new r(i,t);throw new Error("HMAC algorithm "+e+" is not supported in the browser SDK")},createSign:function(){throw new Error("createSign is not implemented in the browser")}}},{"./browserHmac":12,"./browserMd5":13,"./browserSha1":14,"./browserSha256":15}],11:[function(e,t,n){var r=e("buffer/").Buffer;"undefined"!=typeof ArrayBuffer&&void 0===ArrayBuffer.isView&&(ArrayBuffer.isView=function(e){return o.indexOf(Object.prototype.toString.call(e))>-1});var o=["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]","[object DataView]"];t.exports={isEmptyData:function(e){return"string"==typeof e?0===e.length:0===e.byteLength},convertToBuffer:function(e){return"string"==typeof e&&(e=new r(e,"utf8")),ArrayBuffer.isView(e)?new Uint8Array(e.buffer,e.byteOffset,e.byteLength/Uint8Array.BYTES_PER_ELEMENT):new Uint8Array(e)}}},{"buffer/":86}],12:[function(e,t,n){var r=e("./browserHashUtils");function o(e,t){this.hash=new e,this.outer=new e;var n=function(e,t){var n=r.convertToBuffer(t);if(n.byteLength>e.BLOCK_SIZE){var o=new e;o.update(n),n=o.digest()}var i=new Uint8Array(e.BLOCK_SIZE);return i.set(n),i}(e,t),o=new Uint8Array(e.BLOCK_SIZE);o.set(n);for(var i=0;i<e.BLOCK_SIZE;i++)n[i]^=54,o[i]^=92;for(this.hash.update(n),this.outer.update(o),i=0;i<n.byteLength;i++)n[i]=0}t.exports=o,o.prototype.update=function(e){if(r.isEmptyData(e)||this.error)return this;try{this.hash.update(r.convertToBuffer(e))}catch(e){this.error=e}return this},o.prototype.digest=function(e){return this.outer.finished||this.outer.update(this.hash.digest()),this.outer.digest(e)}},{"./browserHashUtils":11}],13:[function(e,t,n){var r=e("./browserHashUtils"),o=e("buffer/").Buffer,i=64;function a(){this.state=[1732584193,4023233417,2562383102,271733878],this.buffer=new DataView(new ArrayBuffer(i)),this.bufferLength=0,this.bytesHashed=0,this.finished=!1}function s(e,t,n,r,o,i){return((t=(t+e&4294967295)+(r+i&4294967295)&4294967295)<<o|t>>>32-o)+n&4294967295}function c(e,t,n,r,o,i,a){return s(t&n|~t&r,e,t,o,i,a)}function u(e,t,n,r,o,i,a){return s(t&r|n&~r,e,t,o,i,a)}function l(e,t,n,r,o,i,a){return s(t^n^r,e,t,o,i,a)}function p(e,t,n,r,o,i,a){return s(n^(t|~r),e,t,o,i,a)}t.exports=a,a.BLOCK_SIZE=i,a.prototype.update=function(e){if(r.isEmptyData(e))return this;if(this.finished)throw new Error("Attempted to update an already finished hash.");var t=r.convertToBuffer(e),n=0,o=t.byteLength;for(this.bytesHashed+=o;o>0;)this.buffer.setUint8(this.bufferLength++,t[n++]),o--,this.bufferLength===i&&(this.hashBuffer(),this.bufferLength=0);return this},a.prototype.digest=function(e){if(!this.finished){var t=this,n=t.buffer,r=t.bufferLength,a=8*t.bytesHashed;if(n.setUint8(this.bufferLength++,128),r%i>=56){for(var s=this.bufferLength;s<i;s++)n.setUint8(s,0);this.hashBuffer(),this.bufferLength=0}for(s=this.bufferLength;s<56;s++)n.setUint8(s,0);n.setUint32(56,a>>>0,!0),n.setUint32(60,Math.floor(a/4294967296),!0),this.hashBuffer(),this.finished=!0}var c=new DataView(new ArrayBuffer(16));for(s=0;s<4;s++)c.setUint32(4*s,this.state[s],!0);var u=new o(c.buffer,c.byteOffset,c.byteLength);return e?u.toString(e):u},a.prototype.hashBuffer=function(){var e=this.buffer,t=this.state,n=t[0],r=t[1],o=t[2],i=t[3];n=c(n,r,o,i,e.getUint32(0,!0),7,3614090360),i=c(i,n,r,o,e.getUint32(4,!0),12,3905402710),o=c(o,i,n,r,e.getUint32(8,!0),17,606105819),r=c(r,o,i,n,e.getUint32(12,!0),22,3250441966),n=c(n,r,o,i,e.getUint32(16,!0),7,4118548399),i=c(i,n,r,o,e.getUint32(20,!0),12,1200080426),o=c(o,i,n,r,e.getUint32(24,!0),17,2821735955),r=c(r,o,i,n,e.getUint32(28,!0),22,4249261313),n=c(n,r,o,i,e.getUint32(32,!0),7,1770035416),i=c(i,n,r,o,e.getUint32(36,!0),12,2336552879),o=c(o,i,n,r,e.getUint32(40,!0),17,4294925233),r=c(r,o,i,n,e.getUint32(44,!0),22,2304563134),n=c(n,r,o,i,e.getUint32(48,!0),7,1804603682),i=c(i,n,r,o,e.getUint32(52,!0),12,4254626195),o=c(o,i,n,r,e.getUint32(56,!0),17,2792965006),n=u(n,r=c(r,o,i,n,e.getUint32(60,!0),22,1236535329),o,i,e.getUint32(4,!0),5,4129170786),i=u(i,n,r,o,e.getUint32(24,!0),9,3225465664),o=u(o,i,n,r,e.getUint32(44,!0),14,643717713),r=u(r,o,i,n,e.getUint32(0,!0),20,3921069994),n=u(n,r,o,i,e.getUint32(20,!0),5,3593408605),i=u(i,n,r,o,e.getUint32(40,!0),9,38016083),o=u(o,i,n,r,e.getUint32(60,!0),14,3634488961),r=u(r,o,i,n,e.getUint32(16,!0),20,3889429448),n=u(n,r,o,i,e.getUint32(36,!0),5,568446438),i=u(i,n,r,o,e.getUint32(56,!0),9,3275163606),o=u(o,i,n,r,e.getUint32(12,!0),14,4107603335),r=u(r,o,i,n,e.getUint32(32,!0),20,1163531501),n=u(n,r,o,i,e.getUint32(52,!0),5,2850285829),i=u(i,n,r,o,e.getUint32(8,!0),9,4243563512),o=u(o,i,n,r,e.getUint32(28,!0),14,1735328473),n=l(n,r=u(r,o,i,n,e.getUint32(48,!0),20,2368359562),o,i,e.getUint32(20,!0),4,4294588738),i=l(i,n,r,o,e.getUint32(32,!0),11,2272392833),o=l(o,i,n,r,e.getUint32(44,!0),16,1839030562),r=l(r,o,i,n,e.getUint32(56,!0),23,4259657740),n=l(n,r,o,i,e.getUint32(4,!0),4,2763975236),i=l(i,n,r,o,e.getUint32(16,!0),11,1272893353),o=l(o,i,n,r,e.getUint32(28,!0),16,4139469664),r=l(r,o,i,n,e.getUint32(40,!0),23,3200236656),n=l(n,r,o,i,e.getUint32(52,!0),4,681279174),i=l(i,n,r,o,e.getUint32(0,!0),11,3936430074),o=l(o,i,n,r,e.getUint32(12,!0),16,3572445317),r=l(r,o,i,n,e.getUint32(24,!0),23,76029189),n=l(n,r,o,i,e.getUint32(36,!0),4,3654602809),i=l(i,n,r,o,e.getUint32(48,!0),11,3873151461),o=l(o,i,n,r,e.getUint32(60,!0),16,530742520),n=p(n,r=l(r,o,i,n,e.getUint32(8,!0),23,3299628645),o,i,e.getUint32(0,!0),6,4096336452),i=p(i,n,r,o,e.getUint32(28,!0),10,1126891415),o=p(o,i,n,r,e.getUint32(56,!0),15,2878612391),r=p(r,o,i,n,e.getUint32(20,!0),21,4237533241),n=p(n,r,o,i,e.getUint32(48,!0),6,1700485571),i=p(i,n,r,o,e.getUint32(12,!0),10,2399980690),o=p(o,i,n,r,e.getUint32(40,!0),15,4293915773),r=p(r,o,i,n,e.getUint32(4,!0),21,2240044497),n=p(n,r,o,i,e.getUint32(32,!0),6,1873313359),i=p(i,n,r,o,e.getUint32(60,!0),10,4264355552),o=p(o,i,n,r,e.getUint32(24,!0),15,2734768916),r=p(r,o,i,n,e.getUint32(52,!0),21,1309151649),n=p(n,r,o,i,e.getUint32(16,!0),6,4149444226),i=p(i,n,r,o,e.getUint32(44,!0),10,3174756917),o=p(o,i,n,r,e.getUint32(8,!0),15,718787259),r=p(r,o,i,n,e.getUint32(36,!0),21,3951481745),t[0]=n+t[0]&4294967295,t[1]=r+t[1]&4294967295,t[2]=o+t[2]&4294967295,t[3]=i+t[3]&4294967295}},{"./browserHashUtils":11,"buffer/":86}],14:[function(e,t,n){var r=e("buffer/").Buffer,o=e("./browserHashUtils");function i(){this.h0=1732584193,this.h1=4023233417,this.h2=2562383102,this.h3=271733878,this.h4=3285377520,this.block=new Uint32Array(80),this.offset=0,this.shift=24,this.totalLength=0}new Uint32Array([1518500249,1859775393,-1894007588,-899497514]),Math.pow(2,53),t.exports=i,i.BLOCK_SIZE=64,i.prototype.update=function(e){if(this.finished)throw new Error("Attempted to update an already finished hash.");if(o.isEmptyData(e))return this;var t=(e=o.convertToBuffer(e)).length;this.totalLength+=8*t;for(var n=0;n<t;n++)this.write(e[n]);return this},i.prototype.write=function(e){this.block[this.offset]|=(255&e)<<this.shift,this.shift?this.shift-=8:(this.offset++,this.shift=24),16===this.offset&&this.processBlock()},i.prototype.digest=function(e){this.write(128),(this.offset>14||14===this.offset&&this.shift<24)&&this.processBlock(),this.offset=14,this.shift=24,this.write(0),this.write(0),this.write(this.totalLength>0xffffffffff?this.totalLength/1099511627776:0),this.write(this.totalLength>4294967295?this.totalLength/4294967296:0);for(var t=24;t>=0;t-=8)this.write(this.totalLength>>t);var n=new r(20),o=new DataView(n.buffer);return o.setUint32(0,this.h0,!1),o.setUint32(4,this.h1,!1),o.setUint32(8,this.h2,!1),o.setUint32(12,this.h3,!1),o.setUint32(16,this.h4,!1),e?n.toString(e):n},i.prototype.processBlock=function(){for(var e=16;e<80;e++){var t=this.block[e-3]^this.block[e-8]^this.block[e-14]^this.block[e-16];this.block[e]=t<<1|t>>>31}var n,r,o=this.h0,i=this.h1,a=this.h2,s=this.h3,c=this.h4;for(e=0;e<80;e++){e<20?(n=s^i&(a^s),r=1518500249):e<40?(n=i^a^s,r=1859775393):e<60?(n=i&a|s&(i|a),r=2400959708):(n=i^a^s,r=3395469782);var u=(o<<5|o>>>27)+n+c+r+(0|this.block[e]);c=s,s=a,a=i<<30|i>>>2,i=o,o=u}for(this.h0=this.h0+o|0,this.h1=this.h1+i|0,this.h2=this.h2+a|0,this.h3=this.h3+s|0,this.h4=this.h4+c|0,this.offset=0,e=0;e<16;e++)this.block[e]=0}},{"./browserHashUtils":11,"buffer/":86}],15:[function(e,t,n){var r=e("buffer/").Buffer,o=e("./browserHashUtils"),i=64,a=new Uint32Array([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]),s=Math.pow(2,53)-1;function c(){this.state=[1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225],this.temp=new Int32Array(64),this.buffer=new Uint8Array(64),this.bufferLength=0,this.bytesHashed=0,this.finished=!1}t.exports=c,c.BLOCK_SIZE=i,c.prototype.update=function(e){if(this.finished)throw new Error("Attempted to update an already finished hash.");if(o.isEmptyData(e))return this;var t=0,n=(e=o.convertToBuffer(e)).byteLength;if(this.bytesHashed+=n,8*this.bytesHashed>s)throw new Error("Cannot hash more than 2^53 - 1 bits");for(;n>0;)this.buffer[this.bufferLength++]=e[t++],n--,this.bufferLength===i&&(this.hashBuffer(),this.bufferLength=0);return this},c.prototype.digest=function(e){if(!this.finished){var t=8*this.bytesHashed,n=new DataView(this.buffer.buffer,this.buffer.byteOffset,this.buffer.byteLength),o=this.bufferLength;if(n.setUint8(this.bufferLength++,128),o%i>=56){for(var a=this.bufferLength;a<i;a++)n.setUint8(a,0);this.hashBuffer(),this.bufferLength=0}for(a=this.bufferLength;a<56;a++)n.setUint8(a,0);n.setUint32(56,Math.floor(t/4294967296),!0),n.setUint32(60,t),this.hashBuffer(),this.finished=!0}var s=new r(32);for(a=0;a<8;a++)s[4*a]=this.state[a]>>>24&255,s[4*a+1]=this.state[a]>>>16&255,s[4*a+2]=this.state[a]>>>8&255,s[4*a+3]=this.state[a]>>>0&255;return e?s.toString(e):s},c.prototype.hashBuffer=function(){for(var e=this.buffer,t=this.state,n=t[0],r=t[1],o=t[2],s=t[3],c=t[4],u=t[5],l=t[6],p=t[7],d=0;d<i;d++){if(d<16)this.temp[d]=(255&e[4*d])<<24|(255&e[4*d+1])<<16|(255&e[4*d+2])<<8|255&e[4*d+3];else{var f=this.temp[d-2],h=(f>>>17|f<<15)^(f>>>19|f<<13)^f>>>10,g=((f=this.temp[d-15])>>>7|f<<25)^(f>>>18|f<<14)^f>>>3;this.temp[d]=(h+this.temp[d-7]|0)+(g+this.temp[d-16]|0)}var m=(((c>>>6|c<<26)^(c>>>11|c<<21)^(c>>>25|c<<7))+(c&u^~c&l)|0)+(p+(a[d]+this.temp[d]|0)|0)|0,v=((n>>>2|n<<30)^(n>>>13|n<<19)^(n>>>22|n<<10))+(n&r^n&o^r&o)|0;p=l,l=u,u=c,c=s+m|0,s=o,o=r,r=n,n=m+v|0}t[0]+=n,t[1]+=r,t[2]+=o,t[3]+=s,t[4]+=c,t[5]+=u,t[6]+=l,t[7]+=p}},{"./browserHashUtils":11,"buffer/":86}],16:[function(e,t,n){(function(n){(function(){var n=e("./util");n.crypto.lib=e("./browserCryptoLib"),n.Buffer=e("buffer/").Buffer,n.url=e("url/"),n.querystring=e("querystring/"),n.realClock=e("./realclock/browserClock"),n.environment="js",n.createEventStream=e("./event-stream/buffered-create-event-stream").createEventStream,n.isBrowser=function(){return!0},n.isNode=function(){return!1};var r=e("./core");if(t.exports=r,e("./credentials"),e("./credentials/credential_provider_chain"),e("./credentials/temporary_credentials"),e("./credentials/chainable_temporary_credentials"),e("./credentials/web_identity_credentials"),e("./credentials/cognito_identity_credentials"),e("./credentials/saml_credentials"),r.XML.Parser=e("./xml/browser_parser"),e("./http/xhr"),void 0===o)var o={browser:!0}}).call(this)}).call(this,e("_process"))},{"./browserCryptoLib":10,"./core":19,"./credentials":20,"./credentials/chainable_temporary_credentials":21,"./credentials/cognito_identity_credentials":22,"./credentials/credential_provider_chain":23,"./credentials/saml_credentials":24,"./credentials/temporary_credentials":25,"./credentials/web_identity_credentials":26,"./event-stream/buffered-create-event-stream":28,"./http/xhr":36,"./realclock/browserClock":54,"./util":74,"./xml/browser_parser":75,_process:91,"buffer/":86,"querystring/":98,"url/":100}],17:[function(e,t,n){var r,o=e("./core");e("./credentials"),e("./credentials/credential_provider_chain"),o.Config=o.util.inherit({constructor:function(e){void 0===e&&(e={}),e=this.extractCredentials(e),o.util.each.call(this,this.keys,(function(t,n){this.set(t,e[t],n)}))},getCredentials:function(e){var t,n=this;function r(t){e(t,t?null:n.credentials)}function i(e,t){return new o.util.error(t||new Error,{code:"CredentialsError",message:e,name:"CredentialsError"})}n.credentials?"function"==typeof n.credentials.get?n.credentials.get((function(e){e&&(e=i("Could not load credentials from "+n.credentials.constructor.name,e)),r(e)})):(t=null,n.credentials.accessKeyId&&n.credentials.secretAccessKey||(t=i("Missing credentials")),r(t)):n.credentialProvider?n.credentialProvider.resolve((function(e,t){e&&(e=i("Could not load credentials from any providers",e)),n.credentials=t,r(e)})):r(i("No credentials to load"))},getToken:function(e){var t,n=this;function r(t){e(t,t?null:n.token)}function i(e,t){return new o.util.error(t||new Error,{code:"TokenError",message:e,name:"TokenError"})}n.token?"function"==typeof n.token.get?n.token.get((function(e){e&&(e=i("Could not load token from "+n.token.constructor.name,e)),r(e)})):(t=null,n.token.token||(t=i("Missing token")),r(t)):n.tokenProvider?n.tokenProvider.resolve((function(e,t){e&&(e=i("Could not load token from any providers",e)),n.token=t,r(e)})):r(i("No token to load"))},update:function(e,t){t=t||!1,e=this.extractCredentials(e),o.util.each.call(this,e,(function(e,n){(t||Object.prototype.hasOwnProperty.call(this.keys,e)||o.Service.hasService(e))&&this.set(e,n)}))},loadFromPath:function(e){this.clear();var t=JSON.parse(o.util.readFileSync(e)),n=new o.FileSystemCredentials(e),r=new o.CredentialProviderChain;return r.providers.unshift(n),r.resolve((function(e,n){if(e)throw e;t.credentials=n})),this.constructor(t),this},clear:function(){o.util.each.call(this,this.keys,(function(e){delete this[e]})),this.set("credentials",void 0),this.set("credentialProvider",void 0)},set:function(e,t,n){void 0===t?(void 0===n&&(n=this.keys[e]),this[e]="function"==typeof n?n.call(this):n):"httpOptions"===e&&this[e]?this[e]=o.util.merge(this[e],t):this[e]=t},keys:{credentials:null,credentialProvider:null,region:null,logger:null,apiVersions:{},apiVersion:null,endpoint:void 0,httpOptions:{timeout:12e4},maxRetries:void 0,maxRedirects:10,paramValidation:!0,sslEnabled:!0,s3ForcePathStyle:!1,s3BucketEndpoint:!1,s3DisableBodySigning:!0,s3UsEast1RegionalEndpoint:"legacy",s3UseArnRegion:void 0,computeChecksums:!0,convertResponseTypes:!0,correctClockSkew:!1,customUserAgent:null,dynamoDbCrc32:!0,systemClockOffset:0,signatureVersion:null,signatureCache:!0,retryDelayOptions:{},useAccelerateEndpoint:!1,clientSideMonitoring:!1,endpointDiscoveryEnabled:void 0,endpointCacheSize:1e3,hostPrefixEnabled:!0,stsRegionalEndpoints:"legacy",useFipsEndpoint:!1,useDualstackEndpoint:!1,token:null},extractCredentials:function(e){return e.accessKeyId&&e.secretAccessKey&&((e=o.util.copy(e)).credentials=new o.Credentials(e)),e},setPromisesDependency:function(e){r=e,null===e&&"function"==typeof Promise&&(r=Promise);var t=[o.Request,o.Credentials,o.CredentialProviderChain];o.S3&&(t.push(o.S3),o.S3.ManagedUpload&&t.push(o.S3.ManagedUpload)),o.util.addPromises(t,r)},getPromisesDependency:function(){return r}}),o.config=new o.Config},{"./core":19,"./credentials":20,"./credentials/credential_provider_chain":23}],18:[function(e,t,n){(function(n){(function(){var r=e("./core");function o(e,t){if("string"==typeof e){if(["legacy","regional"].indexOf(e.toLowerCase())>=0)return e.toLowerCase();throw r.util.error(new Error,t)}}t.exports=function(e,t){var i;if((e=e||{})[t.clientConfig]&&(i=o(e[t.clientConfig],{code:"InvalidConfiguration",message:'invalid "'+t.clientConfig+'" configuration. Expect "legacy"  or "regional". Got "'+e[t.clientConfig]+'".'})))return i;if(!r.util.isNode())return i;if(Object.prototype.hasOwnProperty.call(n.env,t.env)&&(i=o(n.env[t.env],{code:"InvalidEnvironmentalVariable",message:"invalid "+t.env+' environmental variable. Expect "legacy"  or "regional". Got "'+n.env[t.env]+'".'})))return i;var a={};try{a=r.util.getProfilesFromSharedConfig(r.util.iniLoader)[n.env.AWS_PROFILE||r.util.defaultProfile]}catch(e){}return a&&Object.prototype.hasOwnProperty.call(a,t.sharedConfig)&&(i=o(a[t.sharedConfig],{code:"InvalidConfiguration",message:"invalid "+t.sharedConfig+' profile config. Expect "legacy"  or "regional". Got "'+a[t.sharedConfig]+'".'})),i}}).call(this)}).call(this,e("_process"))},{"./core":19,_process:91}],19:[function(e,t,n){var r={util:e("./util")};({}).toString(),t.exports=r,r.util.update(r,{VERSION:"2.1589.0",Signers:{},Protocol:{Json:e("./protocol/json"),Query:e("./protocol/query"),Rest:e("./protocol/rest"),RestJson:e("./protocol/rest_json"),RestXml:e("./protocol/rest_xml")},XML:{Builder:e("./xml/builder"),Parser:null},JSON:{Builder:e("./json/builder"),Parser:e("./json/parser")},Model:{Api:e("./model/api"),Operation:e("./model/operation"),Shape:e("./model/shape"),Paginator:e("./model/paginator"),ResourceWaiter:e("./model/resource_waiter")},apiLoader:e("./api_loader"),EndpointCache:e("../vendor/endpoint-cache").EndpointCache}),e("./sequential_executor"),e("./service"),e("./config"),e("./http"),e("./event_listeners"),e("./request"),e("./response"),e("./resource_waiter"),e("./signers/request_signer"),e("./param_validator"),e("./maintenance_mode_message"),r.events=new r.SequentialExecutor,r.util.memoizedProperty(r,"endpointCache",(function(){return new r.EndpointCache(r.config.endpointCacheSize)}),!0)},{"../vendor/endpoint-cache":111,"./api_loader":9,"./config":17,"./event_listeners":34,"./http":35,"./json/builder":37,"./json/parser":38,"./maintenance_mode_message":39,"./model/api":40,"./model/operation":42,"./model/paginator":43,"./model/resource_waiter":44,"./model/shape":45,"./param_validator":46,"./protocol/json":48,"./protocol/query":49,"./protocol/rest":50,"./protocol/rest_json":51,"./protocol/rest_xml":52,"./request":58,"./resource_waiter":59,"./response":60,"./sequential_executor":61,"./service":62,"./signers/request_signer":66,"./util":74,"./xml/builder":76}],20:[function(e,t,n){var r=e("./core");r.Credentials=r.util.inherit({constructor:function(){if(r.util.hideProperties(this,["secretAccessKey"]),this.expired=!1,this.expireTime=null,this.refreshCallbacks=[],1===arguments.length&&"object"===o(arguments[0])){var e=arguments[0].credentials||arguments[0];this.accessKeyId=e.accessKeyId,this.secretAccessKey=e.secretAccessKey,this.sessionToken=e.sessionToken}else this.accessKeyId=arguments[0],this.secretAccessKey=arguments[1],this.sessionToken=arguments[2]},expiryWindow:15,needsRefresh:function(){var e=r.util.date.getDate().getTime(),t=new Date(e+1e3*this.expiryWindow);return!!(this.expireTime&&t>this.expireTime)||this.expired||!this.accessKeyId||!this.secretAccessKey},get:function(e){var t=this;this.needsRefresh()?this.refresh((function(n){n||(t.expired=!1),e&&e(n)})):e&&e()},refresh:function(e){this.expired=!1,e()},coalesceRefresh:function(e,t){var n=this;1===n.refreshCallbacks.push(e)&&n.load((function(e){r.util.arrayEach(n.refreshCallbacks,(function(n){t?n(e):r.util.defer((function(){n(e)}))})),n.refreshCallbacks.length=0}))},load:function(e){e()}}),r.Credentials.addPromisesToClass=function(e){this.prototype.getPromise=r.util.promisifyMethod("get",e),this.prototype.refreshPromise=r.util.promisifyMethod("refresh",e)},r.Credentials.deletePromisesFromClass=function(){delete this.prototype.getPromise,delete this.prototype.refreshPromise},r.util.addPromises(r.Credentials)},{"./core":19}],21:[function(e,t,n){var r=e("../core"),o=e("../../clients/sts");r.ChainableTemporaryCredentials=r.util.inherit(r.Credentials,{constructor:function(e){r.Credentials.call(this),e=e||{},this.errorCode="ChainableTemporaryCredentialsProviderFailure",this.expired=!0,this.tokenCodeFn=null;var t=r.util.copy(e.params)||{};if(t.RoleArn&&(t.RoleSessionName=t.RoleSessionName||"temporary-credentials"),t.SerialNumber){if(!e.tokenCodeFn||"function"!=typeof e.tokenCodeFn)throw new r.util.error(new Error("tokenCodeFn must be a function when params.SerialNumber is given"),{code:this.errorCode});this.tokenCodeFn=e.tokenCodeFn}var n=r.util.merge({params:t,credentials:e.masterCredentials||r.config.credentials},e.stsConfig||{});this.service=new o(n)},refresh:function(e){this.coalesceRefresh(e||r.util.fn.callback)},load:function(e){var t=this,n=t.service.config.params.RoleArn?"assumeRole":"getSessionToken";this.getTokenCode((function(r,o){var i={};r?e(r):(o&&(i.TokenCode=o),t.service[n](i,(function(n,r){n||t.service.credentialsFrom(r,t),e(n)})))}))},getTokenCode:function(e){var t=this;this.tokenCodeFn?this.tokenCodeFn(this.service.config.params.SerialNumber,(function(n,o){if(n){var i=n;return n instanceof Error&&(i=n.message),void e(r.util.error(new Error("Error fetching MFA token: "+i),{code:t.errorCode}))}e(null,o)})):e(null)}})},{"../../clients/sts":8,"../core":19}],22:[function(e,t,n){var r=e("../core"),i=e("../../clients/cognitoidentity"),a=e("../../clients/sts");r.CognitoIdentityCredentials=r.util.inherit(r.Credentials,{localStorageKey:{id:"aws.cognito.identity-id.",providers:"aws.cognito.identity-providers."},constructor:function(e,t){r.Credentials.call(this),this.expired=!0,this.params=e,this.data=null,this._identityId=null,this._clientConfig=r.util.copy(t||{}),this.loadCachedId();var n=this;Object.defineProperty(this,"identityId",{get:function(){return n.loadCachedId(),n._identityId||n.params.IdentityId},set:function(e){n._identityId=e}})},refresh:function(e){this.coalesceRefresh(e||r.util.fn.callback)},load:function(e){var t=this;t.createClients(),t.data=null,t._identityId=null,t.getId((function(n){n?(t.clearIdOnNotAuthorized(n),e(n)):t.params.RoleArn?t.getCredentialsFromSTS(e):t.getCredentialsForIdentity(e)}))},clearCachedId:function(){this._identityId=null,delete this.params.IdentityId;var e=this.params.IdentityPoolId,t=this.params.LoginId||"";delete this.storage[this.localStorageKey.id+e+t],delete this.storage[this.localStorageKey.providers+e+t]},clearIdOnNotAuthorized:function(e){"NotAuthorizedException"==e.code&&this.clearCachedId()},getId:function(e){var t=this;if("string"==typeof t.params.IdentityId)return e(null,t.params.IdentityId);t.cognito.getId((function(n,r){!n&&r.IdentityId?(t.params.IdentityId=r.IdentityId,e(null,r.IdentityId)):e(n)}))},loadCredentials:function(e,t){e&&t&&(t.expired=!1,t.accessKeyId=e.Credentials.AccessKeyId,t.secretAccessKey=e.Credentials.SecretKey,t.sessionToken=e.Credentials.SessionToken,t.expireTime=e.Credentials.Expiration)},getCredentialsForIdentity:function(e){var t=this;t.cognito.getCredentialsForIdentity((function(n,r){n?t.clearIdOnNotAuthorized(n):(t.cacheId(r),t.data=r,t.loadCredentials(t.data,t)),e(n)}))},getCredentialsFromSTS:function(e){var t=this;t.cognito.getOpenIdToken((function(n,r){n?(t.clearIdOnNotAuthorized(n),e(n)):(t.cacheId(r),t.params.WebIdentityToken=r.Token,t.webIdentityCredentials.refresh((function(n){n||(t.data=t.webIdentityCredentials.data,t.sts.credentialsFrom(t.data,t)),e(n)})))}))},loadCachedId:function(){var e=this;if(r.util.isBrowser()&&!e.params.IdentityId){var t=e.getStorage("id");if(t&&e.params.Logins){var n=Object.keys(e.params.Logins);0!==(e.getStorage("providers")||"").split(",").filter((function(e){return-1!==n.indexOf(e)})).length&&(e.params.IdentityId=t)}else t&&(e.params.IdentityId=t)}},createClients:function(){var e=this._clientConfig;if(this.webIdentityCredentials=this.webIdentityCredentials||new r.WebIdentityCredentials(this.params,e),!this.cognito){var t=r.util.merge({},e);t.params=this.params,this.cognito=new i(t)}this.sts=this.sts||new a(e)},cacheId:function(e){this._identityId=e.IdentityId,this.params.IdentityId=this._identityId,r.util.isBrowser()&&(this.setStorage("id",e.IdentityId),this.params.Logins&&this.setStorage("providers",Object.keys(this.params.Logins).join(",")))},getStorage:function(e){return this.storage[this.localStorageKey[e]+this.params.IdentityPoolId+(this.params.LoginId||"")]},setStorage:function(e,t){try{this.storage[this.localStorageKey[e]+this.params.IdentityPoolId+(this.params.LoginId||"")]=t}catch(e){}},storage:function(){try{var e=r.util.isBrowser()&&null!==window.localStorage&&"object"===o(window.localStorage)?window.localStorage:{};return e["aws.test-storage"]="foobar",delete e["aws.test-storage"],e}catch(e){return{}}}()})},{"../../clients/cognitoidentity":7,"../../clients/sts":8,"../core":19}],23:[function(e,t,n){var r=e("../core");r.CredentialProviderChain=r.util.inherit(r.Credentials,{constructor:function(e){this.providers=e||r.CredentialProviderChain.defaultProviders.slice(0),this.resolveCallbacks=[]},resolve:function(e){var t=this;if(0===t.providers.length)return e(new Error("No providers")),t;if(1===t.resolveCallbacks.push(e)){var n=function(e,a){if(!e&&a||o===i.length)return r.util.arrayEach(t.resolveCallbacks,(function(t){t(e,a)})),void(t.resolveCallbacks.length=0);var s=i[o++];(a="function"==typeof s?s.call():s).get?a.get((function(e){n(e,e?null:a)})):n(null,a)},o=0,i=t.providers.slice(0);n()}return t}}),r.CredentialProviderChain.defaultProviders=[],r.CredentialProviderChain.addPromisesToClass=function(e){this.prototype.resolvePromise=r.util.promisifyMethod("resolve",e)},r.CredentialProviderChain.deletePromisesFromClass=function(){delete this.prototype.resolvePromise},r.util.addPromises(r.CredentialProviderChain)},{"../core":19}],24:[function(e,t,n){var r=e("../core"),o=e("../../clients/sts");r.SAMLCredentials=r.util.inherit(r.Credentials,{constructor:function(e){r.Credentials.call(this),this.expired=!0,this.params=e},refresh:function(e){this.coalesceRefresh(e||r.util.fn.callback)},load:function(e){var t=this;t.createClients(),t.service.assumeRoleWithSAML((function(n,r){n||t.service.credentialsFrom(r,t),e(n)}))},createClients:function(){this.service=this.service||new o({params:this.params})}})},{"../../clients/sts":8,"../core":19}],25:[function(e,t,n){var r=e("../core"),o=e("../../clients/sts");r.TemporaryCredentials=r.util.inherit(r.Credentials,{constructor:function(e,t){r.Credentials.call(this),this.loadMasterCredentials(t),this.expired=!0,this.params=e||{},this.params.RoleArn&&(this.params.RoleSessionName=this.params.RoleSessionName||"temporary-credentials")},refresh:function(e){this.coalesceRefresh(e||r.util.fn.callback)},load:function(e){var t=this;t.createClients(),t.masterCredentials.get((function(){t.service.config.credentials=t.masterCredentials,(t.params.RoleArn?t.service.assumeRole:t.service.getSessionToken).call(t.service,(function(n,r){n||t.service.credentialsFrom(r,t),e(n)}))}))},loadMasterCredentials:function(e){for(this.masterCredentials=e||r.config.credentials;this.masterCredentials.masterCredentials;)this.masterCredentials=this.masterCredentials.masterCredentials;"function"!=typeof this.masterCredentials.get&&(this.masterCredentials=new r.Credentials(this.masterCredentials))},createClients:function(){this.service=this.service||new o({params:this.params})}})},{"../../clients/sts":8,"../core":19}],26:[function(e,t,n){var r=e("../core"),o=e("../../clients/sts");r.WebIdentityCredentials=r.util.inherit(r.Credentials,{constructor:function(e,t){r.Credentials.call(this),this.expired=!0,this.params=e,this.params.RoleSessionName=this.params.RoleSessionName||"web-identity",this.data=null,this._clientConfig=r.util.copy(t||{})},refresh:function(e){this.coalesceRefresh(e||r.util.fn.callback)},load:function(e){var t=this;t.createClients(),t.service.assumeRoleWithWebIdentity((function(n,r){t.data=null,n||(t.data=r,t.service.credentialsFrom(r,t)),e(n)}))},createClients:function(){if(!this.service){var e=r.util.merge({},this._clientConfig);e.params=this.params,this.service=new o(e)}}})},{"../../clients/sts":8,"../core":19}],27:[function(e,t,n){(function(n){(function(){var r=e("./core"),o=e("./util"),i=["AWS_ENABLE_ENDPOINT_DISCOVERY","AWS_ENDPOINT_DISCOVERY_ENABLED"];function a(e){var t=e.service,n=t.api||{},r=(n.operations,{});return t.config.region&&(r.region=t.config.region),n.serviceId&&(r.serviceId=n.serviceId),t.config.credentials.accessKeyId&&(r.accessKeyId=t.config.credentials.accessKeyId),r}function s(e,t,n){n&&null!=t&&"structure"===n.type&&n.required&&n.required.length>0&&o.arrayEach(n.required,(function(r){var o=n.members[r];if(!0===o.endpointDiscoveryId){var i=o.isLocationName?o.name:r;e[i]=String(t[r])}else s(e,t[r],o)}))}function c(e,t){var n={};return s(n,e.params,t),n}function u(e){var t=e.service,n=t.api,i=n.operations?n.operations[e.operation]:void 0,s=c(e,i?i.input:void 0),u=a(e);Object.keys(s).length>0&&(u=o.update(u,s),i&&(u.operation=i.name));var l=r.endpointCache.get(u);if(!l||1!==l.length||""!==l[0].Address)if(l&&l.length>0)e.httpRequest.updateEndpoint(l[0].Address);else{var p=t.makeRequest(n.endpointOperation,{Operation:i.name,Identifiers:s});d(p),p.removeListener("validate",r.EventListeners.Core.VALIDATE_PARAMETERS),p.removeListener("retry",r.EventListeners.Core.RETRY_CHECK),r.endpointCache.put(u,[{Address:"",CachePeriodInMinutes:1}]),p.send((function(e,t){t&&t.Endpoints?r.endpointCache.put(u,t.Endpoints):e&&r.endpointCache.put(u,[{Address:"",CachePeriodInMinutes:1}])}))}}var l={};function p(e,t){var n=e.service,i=n.api,s=i.operations?i.operations[e.operation]:void 0,u=s?s.input:void 0,p=c(e,u),f=a(e);Object.keys(p).length>0&&(f=o.update(f,p),s&&(f.operation=s.name));var h=r.EndpointCache.getKeyString(f),g=r.endpointCache.get(h);if(g&&1===g.length&&""===g[0].Address)return l[h]||(l[h]=[]),void l[h].push({request:e,callback:t});if(g&&g.length>0)e.httpRequest.updateEndpoint(g[0].Address),t();else{var m=n.makeRequest(i.endpointOperation,{Operation:s.name,Identifiers:p});m.removeListener("validate",r.EventListeners.Core.VALIDATE_PARAMETERS),d(m),r.endpointCache.put(h,[{Address:"",CachePeriodInMinutes:60}]),m.send((function(n,i){if(n){if(e.response.error=o.error(n,{retryable:!1}),r.endpointCache.remove(f),l[h]){var a=l[h];o.arrayEach(a,(function(e){e.request.response.error=o.error(n,{retryable:!1}),e.callback()})),delete l[h]}}else i&&(r.endpointCache.put(h,i.Endpoints),e.httpRequest.updateEndpoint(i.Endpoints[0].Address),l[h])&&(a=l[h],o.arrayEach(a,(function(e){e.request.httpRequest.updateEndpoint(i.Endpoints[0].Address),e.callback()})),delete l[h]);t()}))}}function d(e){var t=e.service.api.apiVersion;t&&!e.httpRequest.headers["x-amz-api-version"]&&(e.httpRequest.headers["x-amz-api-version"]=t)}function f(e){var t=e.error,n=e.httpResponse;if(t&&("InvalidEndpointException"===t.code||421===n.statusCode)){var i=e.request,s=i.service.api.operations||{},u=c(i,s[i.operation]?s[i.operation].input:void 0),l=a(i);Object.keys(u).length>0&&(l=o.update(l,u),s[i.operation]&&(l.operation=s[i.operation].name)),r.endpointCache.remove(l)}}function h(e){return["false","0"].indexOf(e)>=0}t.exports={discoverEndpoint:function(e,t){var a=e.service||{};if(function(e){if(e._originalConfig&&e._originalConfig.endpoint&&!0===e._originalConfig.endpointDiscoveryEnabled)throw o.error(new Error,{code:"ConfigurationException",message:"Custom endpoint is supplied; endpointDiscoveryEnabled must not be true."});var t=r.config[e.serviceIdentifier]||{};return Boolean(r.config.endpoint||t.endpoint||e._originalConfig&&e._originalConfig.endpoint)}(a)||e.isPresigned())return t();var s=(a.api.operations||{})[e.operation],c=s?s.endpointDiscoveryRequired:"NULL",l=function(e){var t=e.service||{};if(void 0!==t.config.endpointDiscoveryEnabled)return t.config.endpointDiscoveryEnabled;if(!o.isBrowser()){for(var a=0;a<i.length;a++){var s=i[a];if(Object.prototype.hasOwnProperty.call(n.env,s)){if(""===n.env[s]||void 0===n.env[s])throw o.error(new Error,{code:"ConfigurationException",message:"environmental variable "+s+" cannot be set to nothing"});return!h(n.env[s])}}var c={};try{c=r.util.iniLoader?r.util.iniLoader.loadFrom({isConfig:!0,filename:n.env[r.util.sharedConfigFileEnv]}):{}}catch(e){}var u=c[n.env.AWS_PROFILE||r.util.defaultProfile]||{};if(Object.prototype.hasOwnProperty.call(u,"endpoint_discovery_enabled")){if(void 0===u.endpoint_discovery_enabled)throw o.error(new Error,{code:"ConfigurationException",message:"config file entry 'endpoint_discovery_enabled' cannot be set to nothing"});return!h(u.endpoint_discovery_enabled)}}}(e),d=a.api.hasRequiredEndpointDiscovery;switch((l||d)&&e.httpRequest.appendToUserAgent("endpoint-discovery"),c){case"OPTIONAL":(l||d)&&(u(e),e.addNamedListener("INVALIDATE_CACHED_ENDPOINTS","extractError",f)),t();break;case"REQUIRED":if(!1===l){e.response.error=o.error(new Error,{code:"ConfigurationException",message:"Endpoint Discovery is disabled but "+a.api.className+"."+e.operation+"() requires it. Please check your configurations."}),t();break}e.addNamedListener("INVALIDATE_CACHED_ENDPOINTS","extractError",f),p(e,t);break;default:t()}},requiredDiscoverEndpoint:p,optionalDiscoverEndpoint:u,marshallCustomIdentifiers:c,getCacheKey:a,invalidateCachedEndpoint:f}}).call(this)}).call(this,e("_process"))},{"./core":19,"./util":74,_process:91}],28:[function(e,t,n){var r=e("../event-stream/event-message-chunker").eventMessageChunker,o=e("./parse-event").parseEvent;t.exports={createEventStream:function(e,t,n){for(var i=r(e),a=[],s=0;s<i.length;s++)a.push(o(t,i[s],n));return a}}},{"../event-stream/event-message-chunker":29,"./parse-event":31}],29:[function(e,t,n){t.exports={eventMessageChunker:function(e){for(var t=[],n=0;n<e.length;){var r=e.readInt32BE(n),o=e.slice(n,r+n);n+=r,t.push(o)}return t}}},{}],30:[function(e,t,n){var r=e("../core").util,o=r.buffer.toBuffer;function i(e){if(8!==e.length)throw new Error("Int64 buffers must be exactly 8 bytes");r.Buffer.isBuffer(e)||(e=o(e)),this.bytes=e}function a(e){for(var t=0;t<8;t++)e[t]^=255;for(t=7;t>-1&&(e[t]++,0===e[t]);t--);}i.fromNumber=function(e){if(e>0x8000000000000000||e<-0x8000000000000000)throw new Error(e+" is too large (or, if negative, too small) to represent as an Int64");for(var t=new Uint8Array(8),n=7,r=Math.abs(Math.round(e));n>-1&&r>0;n--,r/=256)t[n]=r;return e<0&&a(t),new i(t)},i.prototype.valueOf=function(){var e=this.bytes.slice(0),t=128&e[0];return t&&a(e),parseInt(e.toString("hex"),16)*(t?-1:1)},i.prototype.toString=function(){return String(this.valueOf())},t.exports={Int64:i}},{"../core":19}],31:[function(e,t,n){var r=e("./parse-message").parseMessage;t.exports={parseEvent:function(e,t,n){var o=r(t),i=o.headers[":message-type"];if(i){if("error"===i.value)throw function(e){var t=e.headers[":error-code"],n=e.headers[":error-message"],r=new Error(n.value||n);return r.code=r.name=t.value||t,r}(o);if("event"!==i.value)return}var a=o.headers[":event-type"],s=n.members[a.value];if(s){var c={},u=s.eventPayloadMemberName;if(u){var l=s.members[u];"binary"===l.type?c[u]=o.body:c[u]=e.parse(o.body.toString(),l)}for(var p=s.eventHeaderMemberNames,d=0;d<p.length;d++){var f=p[d];o.headers[f]&&(c[f]=s.members[f].toType(o.headers[f].value))}var h={};return h[a.value]=c,h}}}},{"./parse-message":32}],32:[function(e,t,n){var r=e("./int64").Int64,o=e("./split-message").splitMessage,i="boolean";function a(e){for(var t={},n=0;n<e.length;){var o=e.readUInt8(n++),a=e.slice(n,n+o).toString();switch(n+=o,e.readUInt8(n++)){case 0:t[a]={type:i,value:!0};break;case 1:t[a]={type:i,value:!1};break;case 2:t[a]={type:"byte",value:e.readInt8(n++)};break;case 3:t[a]={type:"short",value:e.readInt16BE(n)},n+=2;break;case 4:t[a]={type:"integer",value:e.readInt32BE(n)},n+=4;break;case 5:t[a]={type:"long",value:new r(e.slice(n,n+8))},n+=8;break;case 6:var s=e.readUInt16BE(n);n+=2,t[a]={type:"binary",value:e.slice(n,n+s)},n+=s;break;case 7:var c=e.readUInt16BE(n);n+=2,t[a]={type:"string",value:e.slice(n,n+c).toString()},n+=c;break;case 8:t[a]={type:"timestamp",value:new Date(new r(e.slice(n,n+8)).valueOf())},n+=8;break;case 9:var u=e.slice(n,n+16).toString("hex");n+=16,t[a]={type:"uuid",value:u.substr(0,8)+"-"+u.substr(8,4)+"-"+u.substr(12,4)+"-"+u.substr(16,4)+"-"+u.substr(20)};break;default:throw new Error("Unrecognized header type tag")}}return t}t.exports={parseMessage:function(e){var t=o(e);return{headers:a(t.headers),body:t.body}}}},{"./int64":30,"./split-message":33}],33:[function(e,t,n){var r=e("../core").util,o=r.buffer.toBuffer;t.exports={splitMessage:function(e){if(r.Buffer.isBuffer(e)||(e=o(e)),e.length<16)throw new Error("Provided message too short to accommodate event stream message overhead");if(e.length!==e.readUInt32BE(0))throw new Error("Reported message length does not match received message length");var t=e.readUInt32BE(8);if(t!==r.crypto.crc32(e.slice(0,8)))throw new Error("The prelude checksum specified in the message ("+t+") does not match the calculated CRC32 checksum.");var n=e.readUInt32BE(e.length-4);if(n!==r.crypto.crc32(e.slice(0,e.length-4)))throw new Error("The message checksum did not match the expected value of "+n);var i=12+e.readUInt32BE(4);return{headers:e.slice(12,i),body:e.slice(i,e.length-4)}}}},{"../core":19}],34:[function(e,t,n){(function(t){(function(){var n=e("./core"),r=e("./sequential_executor"),o=e("./discover_endpoint").discoverEndpoint;function i(e){if(!e.service.api.operations)return"";var t=e.service.api.operations[e.operation];return t?t.authtype:""}function a(e){var t=e.service;return t.config.signatureVersion?t.config.signatureVersion:t.api.signatureVersion?t.api.signatureVersion:i(e)}n.EventListeners={Core:{}},n.EventListeners={Core:(new r).addNamedListeners((function(e,r){r("VALIDATE_CREDENTIALS","validate",(function(e,t){if(!e.service.api.signatureVersion&&!e.service.config.signatureVersion)return t();"bearer"!==a(e)?e.service.config.getCredentials((function(r){r&&(e.response.error=n.util.error(r,{code:"CredentialsError",message:"Missing credentials in config, if using AWS_CONFIG_FILE, set AWS_SDK_LOAD_CONFIG=1"})),t()})):e.service.config.getToken((function(r){r&&(e.response.error=n.util.error(r,{code:"TokenError"})),t()}))})),e("VALIDATE_REGION","validate",(function(e){if(!e.service.isGlobalEndpoint){var t=new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/);e.service.config.region?t.test(e.service.config.region)||(e.response.error=n.util.error(new Error,{code:"ConfigError",message:"Invalid region in config"})):e.response.error=n.util.error(new Error,{code:"ConfigError",message:"Missing region in config"})}})),e("BUILD_IDEMPOTENCY_TOKENS","validate",(function(e){if(e.service.api.operations){var t=e.service.api.operations[e.operation];if(t){var r=t.idempotentMembers;if(r.length){for(var o=n.util.copy(e.params),i=0,a=r.length;i<a;i++)o[r[i]]||(o[r[i]]=n.util.uuid.v4());e.params=o}}}})),e("VALIDATE_PARAMETERS","validate",(function(e){if(e.service.api.operations){var t=e.service.api.operations[e.operation].input,r=e.service.config.paramValidation;new n.ParamValidator(r).validate(t,e.params)}})),e("COMPUTE_CHECKSUM","afterBuild",(function(e){if(e.service.api.operations){var t=e.service.api.operations[e.operation];if(t){var r=e.httpRequest.body,o=r&&(n.util.Buffer.isBuffer(r)||"string"==typeof r),i=e.httpRequest.headers;if(t.httpChecksumRequired&&e.service.config.computeChecksums&&o&&!i["Content-MD5"]){var a=n.util.crypto.md5(r,"base64");i["Content-MD5"]=a}}}})),r("COMPUTE_SHA256","afterBuild",(function(e,t){if(e.haltHandlersOnError(),e.service.api.operations){var r=e.service.api.operations[e.operation],o=r?r.authtype:"";if(!e.service.api.signatureVersion&&!o&&!e.service.config.signatureVersion)return t();if(e.service.getSignerClass(e)===n.Signers.V4){var i=e.httpRequest.body||"";if(o.indexOf("unsigned-body")>=0)return e.httpRequest.headers["X-Amz-Content-Sha256"]="UNSIGNED-PAYLOAD",t();n.util.computeSha256(i,(function(n,r){n?t(n):(e.httpRequest.headers["X-Amz-Content-Sha256"]=r,t())}))}else t()}})),e("SET_CONTENT_LENGTH","afterBuild",(function(e){var t=i(e),r=n.util.getRequestPayloadShape(e);if(void 0===e.httpRequest.headers["Content-Length"])try{var o=n.util.string.byteLength(e.httpRequest.body);e.httpRequest.headers["Content-Length"]=o}catch(n){if(r&&r.isStreaming){if(r.requiresLength)throw n;if(t.indexOf("unsigned-body")>=0)return void(e.httpRequest.headers["Transfer-Encoding"]="chunked");throw n}throw n}})),e("SET_HTTP_HOST","afterBuild",(function(e){e.httpRequest.headers.Host=e.httpRequest.endpoint.host})),e("SET_TRACE_ID","afterBuild",(function(e){var r="X-Amzn-Trace-Id";if(n.util.isNode()&&!Object.hasOwnProperty.call(e.httpRequest.headers,r)){var o=t.env.AWS_LAMBDA_FUNCTION_NAME,i=t.env._X_AMZN_TRACE_ID;"string"==typeof o&&o.length>0&&"string"==typeof i&&i.length>0&&(e.httpRequest.headers[r]=i)}})),e("RESTART","restart",(function(){var e=this.response.error;e&&e.retryable&&(this.httpRequest=new n.HttpRequest(this.service.endpoint,this.service.region),this.response.retryCount<this.service.config.maxRetries?this.response.retryCount++:this.response.error=null)})),r("DISCOVER_ENDPOINT","sign",o,!0),r("SIGN","sign",(function(e,t){var n=e.service,r=a(e);if(!r||0===r.length)return t();"bearer"===r?n.config.getToken((function(r,o){if(r)return e.response.error=r,t();try{new(n.getSignerClass(e))(e.httpRequest).addAuthorization(o)}catch(t){e.response.error=t}t()})):n.config.getCredentials((function(r,o){if(r)return e.response.error=r,t();try{var i=n.getSkewCorrectedDate(),a=n.getSignerClass(e),s=(e.service.api.operations||{})[e.operation],c=new a(e.httpRequest,n.getSigningName(e),{signatureCache:n.config.signatureCache,operation:s,signatureVersion:n.api.signatureVersion});c.setServiceClientId(n._clientId),delete e.httpRequest.headers.Authorization,delete e.httpRequest.headers.Date,delete e.httpRequest.headers["X-Amz-Date"],c.addAuthorization(o,i),e.signedAt=i}catch(t){e.response.error=t}t()}))})),e("VALIDATE_RESPONSE","validateResponse",(function(e){this.service.successfulResponse(e,this)?(e.data={},e.error=null):(e.data=null,e.error=n.util.error(new Error,{code:"UnknownError",message:"An unknown error occurred."}))})),e("ERROR","error",(function(e,t){if(t.request.service.api.awsQueryCompatible){var n=t.httpResponse.headers,r=n?n["x-amzn-query-error"]:void 0;r&&r.includes(";")&&(t.error.code=r.split(";")[0])}}),!0),r("SEND","send",(function(e,t){function r(r){e.httpResponse.stream=r;var o=e.request.httpRequest.stream,i=e.request.service,a=i.api,s=e.request.operation,c=a.operations[s]||{};r.on("headers",(function(o,a,s){if(e.request.emit("httpHeaders",[o,a,e,s]),!e.httpResponse.streaming)if(2===n.HttpClient.streamsApiVersion){if(c.hasEventOutput&&i.successfulResponse(e))return e.request.emit("httpDone"),void t();r.on("readable",(function(){var t=r.read();null!==t&&e.request.emit("httpData",[t,e])}))}else r.on("data",(function(t){e.request.emit("httpData",[t,e])}))})),r.on("end",(function(){if(!o||!o.didCallback){if(2===n.HttpClient.streamsApiVersion&&c.hasEventOutput&&i.successfulResponse(e))return;e.request.emit("httpDone"),t()}}))}function o(r){if("RequestAbortedError"!==r.code){var o="TimeoutError"===r.code?r.code:"NetworkingError";r=n.util.error(r,{code:o,region:e.request.httpRequest.region,hostname:e.request.httpRequest.endpoint.hostname,retryable:!0})}e.error=r,e.request.emit("httpError",[e.error,e],(function(){t()}))}function i(){var t,i=n.HttpClient.getInstance(),a=e.request.service.config.httpOptions||{};try{var s=i.handleRequest(e.request.httpRequest,a,r,o);(t=s).on("sendProgress",(function(t){e.request.emit("httpUploadProgress",[t,e])})),t.on("receiveProgress",(function(t){e.request.emit("httpDownloadProgress",[t,e])}))}catch(e){o(e)}}e.httpResponse._abortCallback=t,e.error=null,e.data=null,(e.request.service.getSkewCorrectedDate()-this.signedAt)/1e3>=600?this.emit("sign",[this],(function(e){e?t(e):i()})):i()})),e("HTTP_HEADERS","httpHeaders",(function(e,t,r,o){r.httpResponse.statusCode=e,r.httpResponse.statusMessage=o,r.httpResponse.headers=t,r.httpResponse.body=n.util.buffer.toBuffer(""),r.httpResponse.buffers=[],r.httpResponse.numBytes=0;var i=t.date||t.Date,a=r.request.service;if(i){var s=Date.parse(i);a.config.correctClockSkew&&a.isClockSkewed(s)&&a.applyClockOffset(s)}})),e("HTTP_DATA","httpData",(function(e,t){if(e){if(n.util.isNode()){t.httpResponse.numBytes+=e.length;var r=t.httpResponse.headers["content-length"],o={loaded:t.httpResponse.numBytes,total:r};t.request.emit("httpDownloadProgress",[o,t])}t.httpResponse.buffers.push(n.util.buffer.toBuffer(e))}})),e("HTTP_DONE","httpDone",(function(e){if(e.httpResponse.buffers&&e.httpResponse.buffers.length>0){var t=n.util.buffer.concat(e.httpResponse.buffers);e.httpResponse.body=t}delete e.httpResponse.numBytes,delete e.httpResponse.buffers})),e("FINALIZE_ERROR","retry",(function(e){e.httpResponse.statusCode&&(e.error.statusCode=e.httpResponse.statusCode,void 0===e.error.retryable&&(e.error.retryable=this.service.retryableError(e.error,this)))})),e("INVALIDATE_CREDENTIALS","retry",(function(e){if(e.error)switch(e.error.code){case"RequestExpired":case"ExpiredTokenException":case"ExpiredToken":e.error.retryable=!0,e.request.service.config.credentials.expired=!0}})),e("EXPIRED_SIGNATURE","retry",(function(e){var t=e.error;t&&"string"==typeof t.code&&"string"==typeof t.message&&t.code.match(/Signature/)&&t.message.match(/expired/)&&(e.error.retryable=!0)})),e("CLOCK_SKEWED","retry",(function(e){e.error&&this.service.clockSkewError(e.error)&&this.service.config.correctClockSkew&&(e.error.retryable=!0)})),e("REDIRECT","retry",(function(e){e.error&&e.error.statusCode>=300&&e.error.statusCode<400&&e.httpResponse.headers.location&&(this.httpRequest.endpoint=new n.Endpoint(e.httpResponse.headers.location),this.httpRequest.headers.Host=this.httpRequest.endpoint.host,e.error.redirect=!0,e.error.retryable=!0)})),e("RETRY_CHECK","retry",(function(e){e.error&&(e.error.redirect&&e.redirectCount<e.maxRedirects?e.error.retryDelay=0:e.retryCount<e.maxRetries&&(e.error.retryDelay=this.service.retryDelays(e.retryCount,e.error)||0))})),r("RESET_RETRY_STATE","afterRetry",(function(e,t){var n,r=!1;e.error&&(n=e.error.retryDelay||0,e.error.retryable&&e.retryCount<e.maxRetries?(e.retryCount++,r=!0):e.error.redirect&&e.redirectCount<e.maxRedirects&&(e.redirectCount++,r=!0)),r&&n>=0?(e.error=null,setTimeout(t,n)):t()}))})),CorePost:(new r).addNamedListeners((function(e){e("EXTRACT_REQUEST_ID","extractData",n.util.extractRequestId),e("EXTRACT_REQUEST_ID","extractError",n.util.extractRequestId),e("ENOTFOUND_ERROR","httpError",(function(e){if("NetworkingError"===e.code&&function(e){return"ENOTFOUND"===e.errno||"number"==typeof e.errno&&"function"==typeof n.util.getSystemErrorName&&["EAI_NONAME","EAI_NODATA"].indexOf(n.util.getSystemErrorName(e.errno)>=0)}(e)){var t="Inaccessible host: `"+e.hostname+"' at port `"+e.port+"'. This service may not be available in the `"+e.region+"' region.";this.response.error=n.util.error(new Error(t),{code:"UnknownEndpoint",region:e.region,hostname:e.hostname,retryable:!0,originalError:e})}}))})),Logger:(new r).addNamedListeners((function(t){t("LOG_REQUEST","complete",(function(t){var r=t.request,o=r.service.config.logger;if(o){var i=function(){var i=(t.request.service.getSkewCorrectedDate().getTime()-r.startTime.getTime())/1e3,s=!!o.isTTY,c=t.httpResponse.statusCode,u=r.params;r.service.api.operations&&r.service.api.operations[r.operation]&&r.service.api.operations[r.operation].input&&(u=a(r.service.api.operations[r.operation].input,r.params));var l=e("util").inspect(u,!0,null),p="";return s&&(p+="[33m"),p+="[AWS "+r.service.serviceIdentifier+" "+c,p+=" "+i.toString()+"s "+t.retryCount+" retries]",s&&(p+="[0;1m"),p+=" "+n.util.string.lowerFirst(r.operation),p+="("+l+")",s&&(p+="[0m"),p}();"function"==typeof o.log?o.log(i):"function"==typeof o.write&&o.write(i+"\n")}function a(e,t){if(!t)return t;if(e.isSensitive)return"***SensitiveInformation***";switch(e.type){case"structure":var r={};return n.util.each(t,(function(t,n){Object.prototype.hasOwnProperty.call(e.members,t)?r[t]=a(e.members[t],n):r[t]=n})),r;case"list":var o=[];return n.util.arrayEach(t,(function(t,n){o.push(a(e.member,t))})),o;case"map":var i={};return n.util.each(t,(function(t,n){i[t]=a(e.value,n)})),i;default:return t}}}))})),Json:(new r).addNamedListeners((function(t){var n=e("./protocol/json");t("BUILD","build",n.buildRequest),t("EXTRACT_DATA","extractData",n.extractData),t("EXTRACT_ERROR","extractError",n.extractError)})),Rest:(new r).addNamedListeners((function(t){var n=e("./protocol/rest");t("BUILD","build",n.buildRequest),t("EXTRACT_DATA","extractData",n.extractData),t("EXTRACT_ERROR","extractError",n.extractError)})),RestJson:(new r).addNamedListeners((function(t){var n=e("./protocol/rest_json");t("BUILD","build",n.buildRequest),t("EXTRACT_DATA","extractData",n.extractData),t("EXTRACT_ERROR","extractError",n.extractError),t("UNSET_CONTENT_LENGTH","afterBuild",n.unsetContentLength)})),RestXml:(new r).addNamedListeners((function(t){var n=e("./protocol/rest_xml");t("BUILD","build",n.buildRequest),t("EXTRACT_DATA","extractData",n.extractData),t("EXTRACT_ERROR","extractError",n.extractError)})),Query:(new r).addNamedListeners((function(t){var n=e("./protocol/query");t("BUILD","build",n.buildRequest),t("EXTRACT_DATA","extractData",n.extractData),t("EXTRACT_ERROR","extractError",n.extractError)}))}}).call(this)}).call(this,e("_process"))},{"./core":19,"./discover_endpoint":27,"./protocol/json":48,"./protocol/query":49,"./protocol/rest":50,"./protocol/rest_json":51,"./protocol/rest_xml":52,"./sequential_executor":61,_process:91,util:85}],35:[function(e,t,n){var r=e("./core"),o=r.util.inherit;r.Endpoint=o({constructor:function(e,t){if(r.util.hideProperties(this,["slashes","auth","hash","search","query"]),null==e)throw new Error("Invalid endpoint: "+e);if("string"!=typeof e)return r.util.copy(e);e.match(/^http/)||(e=((t&&void 0!==t.sslEnabled?t.sslEnabled:r.config.sslEnabled)?"https":"http")+"://"+e),r.util.update(this,r.util.urlParse(e)),this.port?this.port=parseInt(this.port,10):this.port="https:"===this.protocol?443:80}}),r.HttpRequest=o({constructor:function(e,t){e=new r.Endpoint(e),this.method="POST",this.path=e.path||"/",this.headers={},this.body="",this.endpoint=e,this.region=t,this._userAgent="",this.setUserAgent()},setUserAgent:function(){this._userAgent=this.headers[this.getUserAgentHeaderName()]=r.util.userAgent()},getUserAgentHeaderName:function(){return(r.util.isBrowser()?"X-Amz-":"")+"User-Agent"},appendToUserAgent:function(e){"string"==typeof e&&e&&(this._userAgent+=" "+e),this.headers[this.getUserAgentHeaderName()]=this._userAgent},getUserAgent:function(){return this._userAgent},pathname:function(){return this.path.split("?",1)[0]},search:function(){var e=this.path.split("?",2)[1];return e?(e=r.util.queryStringParse(e),r.util.queryParamsToString(e)):""},updateEndpoint:function(e){var t=new r.Endpoint(e);this.endpoint=t,this.path=t.path||"/",this.headers.Host&&(this.headers.Host=t.host)}}),r.HttpResponse=o({constructor:function(){this.statusCode=void 0,this.headers={},this.body=void 0,this.streaming=!1,this.stream=null},createUnbufferedStream:function(){return this.streaming=!0,this.stream}}),r.HttpClient=o({}),r.HttpClient.getInstance=function(){return void 0===this.singleton&&(this.singleton=new this),this.singleton}},{"./core":19}],36:[function(e,t,n){var r=e("../core"),i=e("events").EventEmitter;e("../http"),r.XHRClient=r.util.inherit({handleRequest:function(e,t,n,a){var s=this,c=e.endpoint,u=new i,l=c.protocol+"//"+c.hostname;80!==c.port&&443!==c.port&&(l+=":"+c.port),l+=e.path;var p=new XMLHttpRequest,d=!1;e.stream=p,p.addEventListener("readystatechange",(function(){try{if(0===p.status)return}catch(e){return}this.readyState>=this.HEADERS_RECEIVED&&!d&&(u.statusCode=p.status,u.headers=s.parseHeaders(p.getAllResponseHeaders()),u.emit("headers",u.statusCode,u.headers,p.statusText),d=!0),this.readyState===this.DONE&&s.finishRequest(p,u)}),!1),p.upload.addEventListener("progress",(function(e){u.emit("sendProgress",e)})),p.addEventListener("progress",(function(e){u.emit("receiveProgress",e)}),!1),p.addEventListener("timeout",(function(){a(r.util.error(new Error("Timeout"),{code:"TimeoutError"}))}),!1),p.addEventListener("error",(function(){a(r.util.error(new Error("Network Failure"),{code:"NetworkingError"}))}),!1),p.addEventListener("abort",(function(){a(r.util.error(new Error("Request aborted"),{code:"RequestAbortedError"}))}),!1),n(u),p.open(e.method,l,!1!==t.xhrAsync),r.util.each(e.headers,(function(e,t){"Content-Length"!==e&&"User-Agent"!==e&&"Host"!==e&&p.setRequestHeader(e,t)})),t.timeout&&!1!==t.xhrAsync&&(p.timeout=t.timeout),t.xhrWithCredentials&&(p.withCredentials=!0);try{p.responseType="arraybuffer"}catch(e){}try{e.body?p.send(e.body):p.send()}catch(t){if(!e.body||"object"!==o(e.body.buffer))throw t;p.send(e.body.buffer)}return u},parseHeaders:function(e){var t={};return r.util.arrayEach(e.split(/\r?\n/),(function(e){var n=e.split(":",1)[0],r=e.substring(n.length+2);n.length>0&&(t[n.toLowerCase()]=r)})),t},finishRequest:function(e,t){var n;if("arraybuffer"===e.responseType&&e.response){var o=e.response;n=new r.util.Buffer(o.byteLength);for(var i=new Uint8Array(o),a=0;a<n.length;++a)n[a]=i[a]}try{n||"string"!=typeof e.responseText||(n=new r.util.Buffer(e.responseText))}catch(e){}n&&t.emit("data",n),t.emit("end")}}),r.HttpClient.prototype=r.XHRClient.prototype,r.HttpClient.streamsApiVersion=1},{"../core":19,"../http":35,events:87}],37:[function(e,t,n){var r=e("../util");function o(){}function i(e,t){if(t&&null!=e)switch(t.type){case"structure":return function(e,t){if(t.isDocument)return e;var n={};return r.each(e,(function(e,r){var o=t.members[e];if(o){if("body"!==o.location)return;var a=o.isLocationName?o.name:e,s=i(r,o);void 0!==s&&(n[a]=s)}})),n}(e,t);case"map":return function(e,t){var n={};return r.each(e,(function(e,r){var o=i(r,t.value);void 0!==o&&(n[e]=o)})),n}(e,t);case"list":return function(e,t){var n=[];return r.arrayEach(e,(function(e){var r=i(e,t.member);void 0!==r&&n.push(r)})),n}(e,t);default:return function(e,t){return t.toWireFormat(e)}(e,t)}}o.prototype.build=function(e,t){return JSON.stringify(i(e,t))},t.exports=o},{"../util":74}],38:[function(e,t,n){var r=e("../util");function o(){}function i(e,t){if(t&&void 0!==e)switch(t.type){case"structure":return function(e,t){if(null!=e){if(t.isDocument)return e;var n={},o=t.members,a=t.api&&t.api.awsQueryCompatible;return r.each(o,(function(t,r){var o=r.isLocationName?r.name:t;if(Object.prototype.hasOwnProperty.call(e,o)){var s=i(e[o],r);void 0!==s&&(n[t]=s)}else a&&r.defaultValue&&"list"===r.type&&(n[t]="function"==typeof r.defaultValue?r.defaultValue():r.defaultValue)})),n}}(e,t);case"map":return function(e,t){if(null!=e){var n={};return r.each(e,(function(e,r){var o=i(r,t.value);n[e]=void 0===o?null:o})),n}}(e,t);case"list":return function(e,t){if(null!=e){var n=[];return r.arrayEach(e,(function(e){var r=i(e,t.member);void 0===r?n.push(null):n.push(r)})),n}}(e,t);default:return function(e,t){return t.toType(e)}(e,t)}}o.prototype.parse=function(e,t){return i(JSON.parse(e),t)},t.exports=o},{"../util":74}],39:[function(e,t,n){(function(e){(function(){var n=["The AWS SDK for JavaScript (v2) will enter maintenance mode","on September 8, 2024 and reach end-of-support on September 8, 2025.\n","Please migrate your code to use AWS SDK for JavaScript (v3).","For more information, check blog post at https://a.co/cUPnyil"].join("\n");t.exports={suppress:!1},setTimeout((function(){t.exports.suppress||void 0!==e&&("object"===o(e.env)&&void 0!==e.env.AWS_EXECUTION_ENV&&0===e.env.AWS_EXECUTION_ENV.indexOf("AWS_Lambda_")||"object"===o(e.env)&&void 0!==e.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE||"function"==typeof e.emitWarning&&e.emitWarning(n,{type:"NOTE"}))}),0)}).call(this)}).call(this,e("_process"))},{_process:91}],40:[function(e,t,n){var r=e("./collection"),o=e("./operation"),i=e("./shape"),a=e("./paginator"),s=e("./resource_waiter"),c=e("../../apis/metadata.json"),u=e("../util"),l=u.property,p=u.memoizedProperty;t.exports=function(e,t){var n=this;e=e||{},(t=t||{}).api=this,e.metadata=e.metadata||{};var d=t.serviceIdentifier;delete t.serviceIdentifier,l(this,"isApi",!0,!1),l(this,"apiVersion",e.metadata.apiVersion),l(this,"endpointPrefix",e.metadata.endpointPrefix),l(this,"signingName",e.metadata.signingName),l(this,"globalEndpoint",e.metadata.globalEndpoint),l(this,"signatureVersion",e.metadata.signatureVersion),l(this,"jsonVersion",e.metadata.jsonVersion),l(this,"targetPrefix",e.metadata.targetPrefix),l(this,"protocol",e.metadata.protocol),l(this,"timestampFormat",e.metadata.timestampFormat),l(this,"xmlNamespaceUri",e.metadata.xmlNamespace),l(this,"abbreviation",e.metadata.serviceAbbreviation),l(this,"fullName",e.metadata.serviceFullName),l(this,"serviceId",e.metadata.serviceId),d&&c[d]&&l(this,"xmlNoDefaultLists",c[d].xmlNoDefaultLists,!1),p(this,"className",(function(){var t=e.metadata.serviceAbbreviation||e.metadata.serviceFullName;return t?("ElasticLoadBalancing"===(t=t.replace(/^Amazon|AWS\s*|\(.*|\s+|\W+/g,""))&&(t="ELB"),t):null})),l(this,"operations",new r(e.operations,t,(function(e,n){return new o(e,n,t)}),u.string.lowerFirst,(function(e,t){!0===t.endpointoperation&&l(n,"endpointOperation",u.string.lowerFirst(e)),t.endpointdiscovery&&!n.hasRequiredEndpointDiscovery&&l(n,"hasRequiredEndpointDiscovery",!0===t.endpointdiscovery.required)}))),l(this,"shapes",new r(e.shapes,t,(function(e,n){return i.create(n,t)}))),l(this,"paginators",new r(e.paginators,t,(function(e,n){return new a(e,n,t)}))),l(this,"waiters",new r(e.waiters,t,(function(e,n){return new s(e,n,t)}),u.string.lowerFirst)),t.documentation&&(l(this,"documentation",e.documentation),l(this,"documentationUrl",e.documentationUrl)),l(this,"awsQueryCompatible",e.metadata.awsQueryCompatible)}},{"../../apis/metadata.json":4,"../util":74,"./collection":41,"./operation":42,"./paginator":43,"./resource_waiter":44,"./shape":45}],41:[function(e,t,n){var r=e("../util").memoizedProperty;function o(e,t,n,o){r(this,o(e),(function(){return n(e,t)}))}t.exports=function(e,t,n,r,i){for(var a in r=r||String,e)Object.prototype.hasOwnProperty.call(e,a)&&(o.call(this,a,e[a],n,r),i&&i(a,e[a]))}},{"../util":74}],42:[function(e,t,n){var r=e("./shape"),o=e("../util"),i=o.property,a=o.memoizedProperty;t.exports=function(e,t,n){var o=this;n=n||{},i(this,"name",t.name||e),i(this,"api",n.api,!1),t.http=t.http||{},i(this,"endpoint",t.endpoint),i(this,"httpMethod",t.http.method||"POST"),i(this,"httpPath",t.http.requestUri||"/"),i(this,"authtype",t.authtype||""),i(this,"endpointDiscoveryRequired",t.endpointdiscovery?t.endpointdiscovery.required?"REQUIRED":"OPTIONAL":"NULL");var s=t.httpChecksumRequired||t.httpChecksum&&t.httpChecksum.requestChecksumRequired;i(this,"httpChecksumRequired",s,!1),a(this,"input",(function(){return t.input?r.create(t.input,n):new r.create({type:"structure"},n)})),a(this,"output",(function(){return t.output?r.create(t.output,n):new r.create({type:"structure"},n)})),a(this,"errors",(function(){var e=[];if(!t.errors)return null;for(var o=0;o<t.errors.length;o++)e.push(r.create(t.errors[o],n));return e})),a(this,"paginator",(function(){return n.api.paginators[e]})),n.documentation&&(i(this,"documentation",t.documentation),i(this,"documentationUrl",t.documentationUrl)),a(this,"idempotentMembers",(function(){var e=[],t=o.input,n=t.members;if(!t.members)return e;for(var r in n)n.hasOwnProperty(r)&&!0===n[r].isIdempotent&&e.push(r);return e})),a(this,"hasEventOutput",(function(){return function(e){var t=e.members,n=e.payload;if(!e.members)return!1;if(n)return t[n].isEventStream;for(var r in t)if(!t.hasOwnProperty(r)&&!0===t[r].isEventStream)return!0;return!1}(o.output)}))}},{"../util":74,"./shape":45}],43:[function(e,t,n){var r=e("../util").property;t.exports=function(e,t){r(this,"inputToken",t.input_token),r(this,"limitKey",t.limit_key),r(this,"moreResults",t.more_results),r(this,"outputToken",t.output_token),r(this,"resultKey",t.result_key)}},{"../util":74}],44:[function(e,t,n){var r=e("../util"),o=r.property;t.exports=function(e,t,n){n=n||{},o(this,"name",e),o(this,"api",n.api,!1),t.operation&&o(this,"operation",r.string.lowerFirst(t.operation));var i=this;["type","description","delay","maxAttempts","acceptors"].forEach((function(e){var n=t[e];n&&o(i,e,n)}))}},{"../util":74}],45:[function(e,t,n){var r=e("./collection"),i=e("../util");function a(e,t,n){null!=n&&i.property.apply(this,arguments)}function s(e,t){e.constructor.prototype[t]||i.memoizedProperty.apply(this,arguments)}function c(e,t,n){t=t||{},a(this,"shape",e.shape),a(this,"api",t.api,!1),a(this,"type",e.type),a(this,"enum",e.enum),a(this,"min",e.min),a(this,"max",e.max),a(this,"pattern",e.pattern),a(this,"location",e.location||this.location||"body"),a(this,"name",this.name||e.xmlName||e.queryName||e.locationName||n),a(this,"isStreaming",e.streaming||this.isStreaming||!1),a(this,"requiresLength",e.requiresLength,!1),a(this,"isComposite",e.isComposite||!1),a(this,"isShape",!0,!1),a(this,"isQueryName",Boolean(e.queryName),!1),a(this,"isLocationName",Boolean(e.locationName),!1),a(this,"isIdempotent",!0===e.idempotencyToken),a(this,"isJsonValue",!0===e.jsonvalue),a(this,"isSensitive",!0===e.sensitive||e.prototype&&!0===e.prototype.sensitive),a(this,"isEventStream",Boolean(e.eventstream),!1),a(this,"isEvent",Boolean(e.event),!1),a(this,"isEventPayload",Boolean(e.eventpayload),!1),a(this,"isEventHeader",Boolean(e.eventheader),!1),a(this,"isTimestampFormatSet",Boolean(e.timestampFormat)||e.prototype&&!0===e.prototype.isTimestampFormatSet,!1),a(this,"endpointDiscoveryId",Boolean(e.endpointdiscoveryid),!1),a(this,"hostLabel",Boolean(e.hostLabel),!1),t.documentation&&(a(this,"documentation",e.documentation),a(this,"documentationUrl",e.documentationUrl)),e.xmlAttribute&&a(this,"isXmlAttribute",e.xmlAttribute||!1),a(this,"defaultValue",null),this.toWireFormat=function(e){return null==e?"":e},this.toType=function(e){return e}}function u(e){c.apply(this,arguments),a(this,"isComposite",!0),e.flattened&&a(this,"flattened",e.flattened||!1)}function l(e,t){var n=this,i=null,l=!this.isShape;u.apply(this,arguments),l&&(a(this,"defaultValue",(function(){return{}})),a(this,"members",{}),a(this,"memberNames",[]),a(this,"required",[]),a(this,"isRequired",(function(){return!1})),a(this,"isDocument",Boolean(e.document))),e.members&&(a(this,"members",new r(e.members,t,(function(e,n){return c.create(n,t,e)}))),s(this,"memberNames",(function(){return e.xmlOrder||Object.keys(e.members)})),e.event&&(s(this,"eventPayloadMemberName",(function(){for(var e=n.members,t=n.memberNames,r=0,o=t.length;r<o;r++)if(e[t[r]].isEventPayload)return t[r]})),s(this,"eventHeaderMemberNames",(function(){for(var e=n.members,t=n.memberNames,r=[],o=0,i=t.length;o<i;o++)e[t[o]].isEventHeader&&r.push(t[o]);return r})))),e.required&&(a(this,"required",e.required),a(this,"isRequired",(function(t){if(!i){i={};for(var n=0;n<e.required.length;n++)i[e.required[n]]=!0}return i[t]}),!1,!0)),a(this,"resultWrapper",e.resultWrapper||null),e.payload&&a(this,"payload",e.payload),"string"==typeof e.xmlNamespace?a(this,"xmlNamespaceUri",e.xmlNamespace):"object"===o(e.xmlNamespace)&&(a(this,"xmlNamespacePrefix",e.xmlNamespace.prefix),a(this,"xmlNamespaceUri",e.xmlNamespace.uri))}function p(e,t){var n=this,r=!this.isShape;if(u.apply(this,arguments),r&&a(this,"defaultValue",(function(){return[]})),e.member&&s(this,"member",(function(){return c.create(e.member,t)})),this.flattened){var o=this.name;s(this,"name",(function(){return n.member.name||o}))}}function d(e,t){var n=!this.isShape;u.apply(this,arguments),n&&(a(this,"defaultValue",(function(){return{}})),a(this,"key",c.create({type:"string"},t)),a(this,"value",c.create({type:"string"},t))),e.key&&s(this,"key",(function(){return c.create(e.key,t)})),e.value&&s(this,"value",(function(){return c.create(e.value,t)}))}function f(){c.apply(this,arguments);var e=["rest-xml","query","ec2"];this.toType=function(t){return t=this.api&&e.indexOf(this.api.protocol)>-1?t||"":t,this.isJsonValue?JSON.parse(t):t&&"function"==typeof t.toString?t.toString():t},this.toWireFormat=function(e){return this.isJsonValue?JSON.stringify(e):e}}function h(){c.apply(this,arguments),this.toType=function(e){var t=i.base64.decode(e);if(this.isSensitive&&i.isNode()&&"function"==typeof i.Buffer.alloc){var n=i.Buffer.alloc(t.length,t);t.fill(0),t=n}return t},this.toWireFormat=i.base64.encode}function g(){h.apply(this,arguments)}function m(){c.apply(this,arguments),this.toType=function(e){return"boolean"==typeof e?e:null==e?null:"true"===e}}c.normalizedTypes={character:"string",double:"float",long:"integer",short:"integer",biginteger:"integer",bigdecimal:"float",blob:"binary"},c.types={structure:l,list:p,map:d,boolean:m,timestamp:function(e){var t=this;if(c.apply(this,arguments),e.timestampFormat)a(this,"timestampFormat",e.timestampFormat);else if(t.isTimestampFormatSet&&this.timestampFormat)a(this,"timestampFormat",this.timestampFormat);else if("header"===this.location)a(this,"timestampFormat","rfc822");else if("querystring"===this.location)a(this,"timestampFormat","iso8601");else if(this.api)switch(this.api.protocol){case"json":case"rest-json":a(this,"timestampFormat","unixTimestamp");break;case"rest-xml":case"query":case"ec2":a(this,"timestampFormat","iso8601")}this.toType=function(e){return null==e?null:"function"==typeof e.toUTCString?e:"string"==typeof e||"number"==typeof e?i.date.parseTimestamp(e):null},this.toWireFormat=function(e){return i.date.format(e,t.timestampFormat)}},float:function(){c.apply(this,arguments),this.toType=function(e){return null==e?null:parseFloat(e)},this.toWireFormat=this.toType},integer:function(){c.apply(this,arguments),this.toType=function(e){return null==e?null:parseInt(e,10)},this.toWireFormat=this.toType},string:f,base64:g,binary:h},c.resolve=function(e,t){if(e.shape){var n=t.api.shapes[e.shape];if(!n)throw new Error("Cannot find shape reference: "+e.shape);return n}return null},c.create=function(e,t,n){if(e.isShape)return e;var r=c.resolve(e,t);if(r){var o=Object.keys(e);t.documentation||(o=o.filter((function(e){return!e.match(/documentation/)})));var i=function(){r.constructor.call(this,e,t,n)};return i.prototype=r,new i}e.type||(e.members?e.type="structure":e.member?e.type="list":e.key?e.type="map":e.type="string");var a=e.type;if(c.normalizedTypes[e.type]&&(e.type=c.normalizedTypes[e.type]),c.types[e.type])return new c.types[e.type](e,t,n);throw new Error("Unrecognized shape type: "+a)},c.shapes={StructureShape:l,ListShape:p,MapShape:d,StringShape:f,BooleanShape:m,Base64Shape:g},t.exports=c},{"../util":74,"./collection":41}],46:[function(e,t,n){var r=e("./core");r.ParamValidator=r.util.inherit({constructor:function(e){!0!==e&&void 0!==e||(e={min:!0}),this.validation=e},validate:function(e,t,n){if(this.errors=[],this.validateMember(e,t||{},n||"params"),this.errors.length>1){var o=this.errors.join("\n* ");throw o="There were "+this.errors.length+" validation errors:\n* "+o,r.util.error(new Error(o),{code:"MultipleValidationErrors",errors:this.errors})}if(1===this.errors.length)throw this.errors[0];return!0},fail:function(e,t){this.errors.push(r.util.error(new Error(t),{code:e}))},validateStructure:function(e,t,n){if(e.isDocument)return!0;var r;this.validateType(t,n,["object"],"structure");for(var o=0;e.required&&o<e.required.length;o++){var i=t[r=e.required[o]];null==i&&this.fail("MissingRequiredParameter","Missing required key '"+r+"' in "+n)}for(r in t)if(Object.prototype.hasOwnProperty.call(t,r)){var a=t[r],s=e.members[r];if(void 0!==s){var c=[n,r].join(".");this.validateMember(s,a,c)}else null!=a&&this.fail("UnexpectedParameter","Unexpected key '"+r+"' found in "+n)}return!0},validateMember:function(e,t,n){switch(e.type){case"structure":return this.validateStructure(e,t,n);case"list":return this.validateList(e,t,n);case"map":return this.validateMap(e,t,n);default:return this.validateScalar(e,t,n)}},validateList:function(e,t,n){if(this.validateType(t,n,[Array])){this.validateRange(e,t.length,n,"list member count");for(var r=0;r<t.length;r++)this.validateMember(e.member,t[r],n+"["+r+"]")}},validateMap:function(e,t,n){if(this.validateType(t,n,["object"],"map")){var r=0;for(var o in t)Object.prototype.hasOwnProperty.call(t,o)&&(this.validateMember(e.key,o,n+"[key='"+o+"']"),this.validateMember(e.value,t[o],n+"['"+o+"']"),r++);this.validateRange(e,r,n,"map member count")}},validateScalar:function(e,t,n){switch(e.type){case null:case void 0:case"string":return this.validateString(e,t,n);case"base64":case"binary":return this.validatePayload(t,n);case"integer":case"float":return this.validateNumber(e,t,n);case"boolean":return this.validateType(t,n,["boolean"]);case"timestamp":return this.validateType(t,n,[Date,/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/,"number"],"Date object, ISO-8601 string, or a UNIX timestamp");default:return this.fail("UnkownType","Unhandled type "+e.type+" for "+n)}},validateString:function(e,t,n){var r=["string"];e.isJsonValue&&(r=r.concat(["number","object","boolean"])),null!==t&&this.validateType(t,n,r)&&(this.validateEnum(e,t,n),this.validateRange(e,t.length,n,"string length"),this.validatePattern(e,t,n),this.validateUri(e,t,n))},validateUri:function(e,t,n){"uri"===e.location&&0===t.length&&this.fail("UriParameterError",'Expected uri parameter to have length >= 1, but found "'+t+'" for '+n)},validatePattern:function(e,t,n){this.validation.pattern&&void 0!==e.pattern&&(new RegExp(e.pattern).test(t)||this.fail("PatternMatchError",'Provided value "'+t+'" does not match regex pattern /'+e.pattern+"/ for "+n))},validateRange:function(e,t,n,r){this.validation.min&&void 0!==e.min&&t<e.min&&this.fail("MinRangeError","Expected "+r+" >= "+e.min+", but found "+t+" for "+n),this.validation.max&&void 0!==e.max&&t>e.max&&this.fail("MaxRangeError","Expected "+r+" <= "+e.max+", but found "+t+" for "+n)},validateEnum:function(e,t,n){this.validation.enum&&void 0!==e.enum&&-1===e.enum.indexOf(t)&&this.fail("EnumError","Found string value of "+t+", but expected "+e.enum.join("|")+" for "+n)},validateType:function(e,t,n,i){if(null==e)return!1;for(var a=!1,s=0;s<n.length;s++){if("string"==typeof n[s]){if(o(e)===n[s])return!0}else if(n[s]instanceof RegExp){if((e||"").toString().match(n[s]))return!0}else{if(e instanceof n[s])return!0;if(r.util.isType(e,n[s]))return!0;i||a||(n=n.slice()),n[s]=r.util.typeName(n[s])}a=!0}var c=i;c||(c=n.join(", ").replace(/,([^,]+)$/,", or$1"));var u=c.match(/^[aeiou]/i)?"n":"";return this.fail("InvalidParameterType","Expected "+t+" to be a"+u+" "+c),!1},validateNumber:function(e,t,n){if(null!=t){if("string"==typeof t){var r=parseFloat(t);r.toString()===t&&(t=r)}this.validateType(t,n,["number"])&&this.validateRange(e,t,n,"numeric value")}},validatePayload:function(e,t){if(null!=e&&"string"!=typeof e&&(!e||"number"!=typeof e.byteLength)){if(r.util.isNode()){var n=r.util.stream.Stream;if(r.util.Buffer.isBuffer(e)||e instanceof n)return}else if(void 0!==("undefined"==typeof Blob?"undefined":o(Blob))&&e instanceof Blob)return;var i=["Buffer","Stream","File","Blob","ArrayBuffer","DataView"];if(e)for(var a=0;a<i.length;a++){if(r.util.isType(e,i[a]))return;if(r.util.typeName(e.constructor)===i[a])return}this.fail("InvalidParameterType","Expected "+t+" to be a string, Buffer, Stream, Blob, or typed array object")}}})},{"./core":19}],47:[function(e,t,n){var r=e("../util"),o=e("../core");t.exports={populateHostPrefix:function(e){if(!e.service.config.hostPrefixEnabled)return e;var t,n,i,a,s,c=e.service.api.operations[e.operation];if(function(e){var t=e.service.api,n=t.operations[e.operation],o=t.endpointOperation&&t.endpointOperation===r.string.lowerFirst(n.name);return"NULL"!==n.endpointDiscoveryRequired||!0===o}(e))return e;if(c.endpoint&&c.endpoint.hostPrefix){var u=function(e,t,n){return r.each(n.members,(function(n,o){if(!0===o.hostLabel){if("string"!=typeof t[n]||""===t[n])throw r.error(new Error,{message:"Parameter "+n+" should be a non-empty string.",code:"InvalidParameter"});var i=new RegExp("\\{"+n+"\\}","g");e=e.replace(i,t[n])}})),e}(c.endpoint.hostPrefix,e.params,c.input);a=e.httpRequest.endpoint,s=u,a.host&&(a.host=s+a.host),a.hostname&&(a.hostname=s+a.hostname),t=e.httpRequest.endpoint.hostname,n=t.split("."),i=/^[a-zA-Z0-9]{1}$|^[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9]$/,r.arrayEach(n,(function(e){if(!e.length||e.length<1||e.length>63)throw r.error(new Error,{code:"ValidationError",message:"Hostname label length should be between 1 to 63 characters, inclusive."});if(!i.test(e))throw o.util.error(new Error,{code:"ValidationError",message:e+" is not hostname compatible."})}))}return e}}},{"../core":19,"../util":74}],48:[function(e,t,n){var r=e("../util"),o=e("../json/builder"),i=e("../json/parser"),a=e("./helpers").populateHostPrefix;t.exports={buildRequest:function(e){var t=e.httpRequest,n=e.service.api,r=n.targetPrefix+"."+n.operations[e.operation].name,i=n.jsonVersion||"1.0",s=n.operations[e.operation].input,c=new o;1===i&&(i="1.0"),n.awsQueryCompatible&&(t.params||(t.params={}),Object.assign(t.params,e.params)),t.body=c.build(e.params||{},s),t.headers["Content-Type"]="application/x-amz-json-"+i,t.headers["X-Amz-Target"]=r,a(e)},extractError:function(e){var t={},n=e.httpResponse;if(t.code=n.headers["x-amzn-errortype"]||"UnknownError","string"==typeof t.code&&(t.code=t.code.split(":")[0]),n.body.length>0)try{var o=JSON.parse(n.body.toString()),i=o.__type||o.code||o.Code;for(var a in i&&(t.code=i.split("#").pop()),"RequestEntityTooLarge"===t.code?t.message="Request body must be less than 1 MB":t.message=o.message||o.Message||null,o||{})"code"!==a&&"message"!==a&&(t["["+a+"]"]="See error."+a+" for details.",Object.defineProperty(t,a,{value:o[a],enumerable:!1,writable:!0}))}catch(o){t.statusCode=n.statusCode,t.message=n.statusMessage}else t.statusCode=n.statusCode,t.message=n.statusCode.toString();e.error=r.error(new Error,t)},extractData:function(e){var t=e.httpResponse.body.toString()||"{}";if(!1===e.request.service.config.convertResponseTypes)e.data=JSON.parse(t);else{var n=e.request.service.api.operations[e.request.operation].output||{},r=new i;e.data=r.parse(t,n)}}}},{"../json/builder":37,"../json/parser":38,"../util":74,"./helpers":47}],49:[function(e,t,n){var r=e("../core"),o=e("../util"),i=e("../query/query_param_serializer"),a=e("../model/shape"),s=e("./helpers").populateHostPrefix;t.exports={buildRequest:function(e){var t=e.service.api.operations[e.operation],n=e.httpRequest;n.headers["Content-Type"]="application/x-www-form-urlencoded; charset=utf-8",n.params={Version:e.service.api.apiVersion,Action:t.name},(new i).serialize(e.params,t.input,(function(e,t){n.params[e]=t})),n.body=o.queryParamsToString(n.params),s(e)},extractError:function(e){var t,n=e.httpResponse.body.toString();if(n.match("<UnknownOperationException"))t={Code:"UnknownOperation",Message:"Unknown operation "+e.request.operation};else try{t=(new r.XML.Parser).parse(n)}catch(n){t={Code:e.httpResponse.statusCode,Message:e.httpResponse.statusMessage}}t.requestId&&!e.requestId&&(e.requestId=t.requestId),t.Errors&&(t=t.Errors),t.Error&&(t=t.Error),t.Code?e.error=o.error(new Error,{code:t.Code,message:t.Message}):e.error=o.error(new Error,{code:e.httpResponse.statusCode,message:null})},extractData:function(e){var t=e.request,n=t.service.api.operations[t.operation].output||{},i=n;if(i.resultWrapper){var s=a.create({type:"structure"});s.members[i.resultWrapper]=n,s.memberNames=[i.resultWrapper],o.property(n,"name",n.resultWrapper),n=s}var c=new r.XML.Parser;if(n&&n.members&&!n.members._XAMZRequestId){var u=a.create({type:"string"},{api:{protocol:"query"}},"requestId");n.members._XAMZRequestId=u}var l=c.parse(e.httpResponse.body.toString(),n);e.requestId=l._XAMZRequestId||l.requestId,l._XAMZRequestId&&delete l._XAMZRequestId,i.resultWrapper&&l[i.resultWrapper]&&(o.update(l,l[i.resultWrapper]),delete l[i.resultWrapper]),e.data=l}}},{"../core":19,"../model/shape":45,"../query/query_param_serializer":53,"../util":74,"./helpers":47}],50:[function(e,t,n){var r=e("../util"),o=e("./helpers").populateHostPrefix;function i(e,t,n,o){var i=[e,t].join("/");i=i.replace(/\/+/g,"/");var a={},s=!1;if(r.each(n.members,(function(e,t){var n=o[e];if(null!=n)if("uri"===t.location){var c=new RegExp("\\{"+t.name+"(\\+)?\\}");i=i.replace(c,(function(e,t){return(t?r.uriEscapePath:r.uriEscape)(String(n))}))}else"querystring"===t.location&&(s=!0,"list"===t.type?a[t.name]=n.map((function(e){return r.uriEscape(t.member.toWireFormat(e).toString())})):"map"===t.type?r.each(n,(function(e,t){Array.isArray(t)?a[e]=t.map((function(e){return r.uriEscape(String(e))})):a[e]=r.uriEscape(String(t))})):a[t.name]=r.uriEscape(t.toWireFormat(n).toString()))})),s){i+=i.indexOf("?")>=0?"&":"?";var c=[];r.arrayEach(Object.keys(a).sort(),(function(e){Array.isArray(a[e])||(a[e]=[a[e]]);for(var t=0;t<a[e].length;t++)c.push(r.uriEscape(String(e))+"="+a[e][t])})),i+=c.join("&")}return i}t.exports={buildRequest:function(e){!function(e){e.httpRequest.method=e.service.api.operations[e.operation].httpMethod}(e),function(e){var t=e.service.api.operations[e.operation],n=t.input,r=i(e.httpRequest.endpoint.path,t.httpPath,n,e.params);e.httpRequest.path=r}(e),function(e){var t=e.service.api.operations[e.operation];r.each(t.input.members,(function(t,n){var o=e.params[t];null!=o&&("headers"===n.location&&"map"===n.type?r.each(o,(function(t,r){e.httpRequest.headers[n.name+t]=r})):"header"===n.location&&(o=n.toWireFormat(o).toString(),n.isJsonValue&&(o=r.base64.encode(o)),e.httpRequest.headers[n.name]=o))}))}(e),o(e)},extractError:function(){},extractData:function(e){var t=e.request,n={},o=e.httpResponse,i=t.service.api.operations[t.operation].output,a={};r.each(o.headers,(function(e,t){a[e.toLowerCase()]=t})),r.each(i.members,(function(e,t){var i=(t.name||e).toLowerCase();if("headers"===t.location&&"map"===t.type){n[e]={};var s=t.isLocationName?t.name:"",c=new RegExp("^"+s+"(.+)","i");r.each(o.headers,(function(t,r){var o=t.match(c);null!==o&&(n[e][o[1]]=r)}))}else if("header"===t.location){if(void 0!==a[i]){var u=t.isJsonValue?r.base64.decode(a[i]):a[i];n[e]=t.toType(u)}}else"statusCode"===t.location&&(n[e]=parseInt(o.statusCode,10))})),e.data=n},generateURI:i}},{"../util":74,"./helpers":47}],51:[function(e,t,n){var r=e("../util"),o=e("./rest"),i=e("./json"),a=e("../json/builder"),s=e("../json/parser"),c=["GET","HEAD","DELETE"];function u(e,t){if(!e.httpRequest.headers["Content-Type"]){var n=t?"binary/octet-stream":"application/json";e.httpRequest.headers["Content-Type"]=n}}t.exports={buildRequest:function(e){o.buildRequest(e),c.indexOf(e.httpRequest.method)<0&&function(e){var t=new a,n=e.service.api.operations[e.operation].input;if(n.payload){var r,o=n.members[n.payload];r=e.params[n.payload],"structure"===o.type?(e.httpRequest.body=t.build(r||{},o),u(e)):void 0!==r&&(e.httpRequest.body=r,("binary"===o.type||o.isStreaming)&&u(e,!0))}else e.httpRequest.body=t.build(e.params,n),u(e)}(e)},extractError:function(e){i.extractError(e)},extractData:function(e){o.extractData(e);var t=e.request,n=t.service.api.operations[t.operation],a=t.service.api.operations[t.operation].output||{};if(n.hasEventOutput,a.payload){var c=a.members[a.payload],u=e.httpResponse.body;if(c.isEventStream)l=new s,e.data[payload]=r.createEventStream(2===AWS.HttpClient.streamsApiVersion?e.httpResponse.stream:u,l,c);else if("structure"===c.type||"list"===c.type){var l=new s;e.data[a.payload]=l.parse(u,c)}else"binary"===c.type||c.isStreaming?e.data[a.payload]=u:e.data[a.payload]=c.toType(u)}else{var p=e.data;i.extractData(e),e.data=r.merge(p,e.data)}},unsetContentLength:function(e){void 0===r.getRequestPayloadShape(e)&&c.indexOf(e.httpRequest.method)>=0&&delete e.httpRequest.headers["Content-Length"]}}},{"../json/builder":37,"../json/parser":38,"../util":74,"./json":48,"./rest":50}],52:[function(e,t,n){var r=e("../core"),o=e("../util"),i=e("./rest");t.exports={buildRequest:function(e){i.buildRequest(e),["GET","HEAD"].indexOf(e.httpRequest.method)<0&&function(e){var t=e.service.api.operations[e.operation].input,n=new r.XML.Builder,i=e.params,a=t.payload;if(a){var s=t.members[a];if(void 0===(i=i[a]))return;if("structure"===s.type){var c=s.name;e.httpRequest.body=n.toXML(i,s,c,!0)}else e.httpRequest.body=i}else e.httpRequest.body=n.toXML(i,t,t.name||t.shape||o.string.upperFirst(e.operation)+"Request")}(e)},extractError:function(e){var t;i.extractError(e);try{t=(new r.XML.Parser).parse(e.httpResponse.body.toString())}catch(n){t={Code:e.httpResponse.statusCode,Message:e.httpResponse.statusMessage}}t.Errors&&(t=t.Errors),t.Error&&(t=t.Error),t.Code?e.error=o.error(new Error,{code:t.Code,message:t.Message}):e.error=o.error(new Error,{code:e.httpResponse.statusCode,message:null})},extractData:function(e){var t;i.extractData(e);var n=e.request,a=e.httpResponse.body,s=n.service.api.operations[n.operation],c=s.output,u=(s.hasEventOutput,c.payload);if(u){var l=c.members[u];l.isEventStream?(t=new r.XML.Parser,e.data[u]=o.createEventStream(2===r.HttpClient.streamsApiVersion?e.httpResponse.stream:e.httpResponse.body,t,l)):"structure"===l.type?(t=new r.XML.Parser,e.data[u]=t.parse(a.toString(),l)):"binary"===l.type||l.isStreaming?e.data[u]=a:e.data[u]=l.toType(a)}else if(a.length>0){var p=(t=new r.XML.Parser).parse(a.toString(),c);o.update(e.data,p)}}}},{"../core":19,"../util":74,"./rest":50}],53:[function(e,t,n){var r=e("../util");function o(){}function i(e){return e.isQueryName||"ec2"!==e.api.protocol?e.name:e.name[0].toUpperCase()+e.name.substr(1)}function a(e,t,n,o){r.each(n.members,(function(n,r){var a=t[n];if(null!=a){var c=i(r);s(c=e?e+"."+c:c,a,r,o)}}))}function s(e,t,n,o){null!=t&&("structure"===n.type?a(e,t,n,o):"list"===n.type?function(e,t,n,o){var a=n.member||{};0!==t.length?r.arrayEach(t,(function(t,r){var c="."+(r+1);if("ec2"===n.api.protocol)c+="";else if(n.flattened){if(a.name){var u=e.split(".");u.pop(),u.push(i(a)),e=u.join(".")}}else c="."+(a.name?a.name:"member")+c;s(e+c,t,a,o)})):o.call(this,e,null)}(e,t,n,o):"map"===n.type?function(e,t,n,o){var i=1;r.each(t,(function(t,r){var a=(n.flattened?".":".entry.")+i+++".",c=a+(n.key.name||"key"),u=a+(n.value.name||"value");s(e+c,t,n.key,o),s(e+u,r,n.value,o)}))}(e,t,n,o):o(e,n.toWireFormat(t).toString()))}o.prototype.serialize=function(e,t,n){a("",e,t,n)},t.exports=o},{"../util":74}],54:[function(e,t,n){t.exports={now:function(){return"undefined"!=typeof performance&&"function"==typeof performance.now?performance.now():Date.now()}}},{}],55:[function(e,t,n){t.exports={isFipsRegion:function(e){return"string"==typeof e&&(e.startsWith("fips-")||e.endsWith("-fips"))},isGlobalRegion:function(e){return"string"==typeof e&&["aws-global","aws-us-gov-global"].includes(e)},getRealRegion:function(e){return["fips-aws-global","aws-fips","aws-global"].includes(e)?"us-east-1":["fips-aws-us-gov-global","aws-us-gov-global"].includes(e)?"us-gov-west-1":e.replace(/fips-(dkr-|prod-)?|-fips/,"")}}},{}],56:[function(e,t,n){var r=e("./util"),o=e("./region_config_data.json");function i(e,t){r.each(t,(function(t,n){"globalEndpoint"!==t&&(void 0!==e.config[t]&&null!==e.config[t]||(e.config[t]=n))}))}t.exports={configureEndpoint:function(e){for(var t=function(e){var t=e.config.region,n=function(e){if(!e)return null;var t=e.split("-");return t.length<3?null:t.slice(0,t.length-2).join("-")+"-*"}(t),r=e.api.endpointPrefix;return[[t,r],[n,r],[t,"*"],[n,"*"],["*",r],[t,"internal-*"],["*","*"]].map((function(e){return e[0]&&e[1]?e.join("/"):null}))}(e),n=e.config.useFipsEndpoint,r=e.config.useDualstackEndpoint,a=0;a<t.length;a++){var s=t[a];if(s){var c=n?r?o.dualstackFipsRules:o.fipsRules:r?o.dualstackRules:o.rules;if(Object.prototype.hasOwnProperty.call(c,s)){var u=c[s];"string"==typeof u&&(u=o.patterns[u]),e.isGlobalEndpoint=!!u.globalEndpoint,u.signingRegion&&(e.signingRegion=u.signingRegion),u.signatureVersion||(u.signatureVersion="v4");var l="bearer"===(e.api&&e.api.signatureVersion);return void i(e,Object.assign({},u,{signatureVersion:l?"bearer":u.signatureVersion}))}}}},getEndpointSuffix:function(e){for(var t={"^(us|eu|ap|sa|ca|me)\\-\\w+\\-\\d+$":"amazonaws.com","^cn\\-\\w+\\-\\d+$":"amazonaws.com.cn","^us\\-gov\\-\\w+\\-\\d+$":"amazonaws.com","^us\\-iso\\-\\w+\\-\\d+$":"c2s.ic.gov","^us\\-isob\\-\\w+\\-\\d+$":"sc2s.sgov.gov"},n=Object.keys(t),r=0;r<n.length;r++){var o=RegExp(n[r]),i=t[n[r]];if(o.test(e))return i}return"amazonaws.com"}}},{"./region_config_data.json":57,"./util":74}],57:[function(e,t,n){t.exports={rules:{"*/*":{endpoint:"{service}.{region}.amazonaws.com"},"cn-*/*":{endpoint:"{service}.{region}.amazonaws.com.cn"},"eu-isoe-*/*":"euIsoe","us-iso-*/*":"usIso","us-isob-*/*":"usIsob","*/budgets":"globalSSL","*/cloudfront":"globalSSL","*/sts":"globalSSL","*/importexport":{endpoint:"{service}.amazonaws.com",signatureVersion:"v2",globalEndpoint:!0},"*/route53":"globalSSL","cn-*/route53":{endpoint:"{service}.amazonaws.com.cn",globalEndpoint:!0,signingRegion:"cn-northwest-1"},"us-gov-*/route53":"globalGovCloud","us-iso-*/route53":{endpoint:"{service}.c2s.ic.gov",globalEndpoint:!0,signingRegion:"us-iso-east-1"},"us-isob-*/route53":{endpoint:"{service}.sc2s.sgov.gov",globalEndpoint:!0,signingRegion:"us-isob-east-1"},"*/waf":"globalSSL","*/iam":"globalSSL","cn-*/iam":{endpoint:"{service}.cn-north-1.amazonaws.com.cn",globalEndpoint:!0,signingRegion:"cn-north-1"},"us-iso-*/iam":{endpoint:"{service}.us-iso-east-1.c2s.ic.gov",globalEndpoint:!0,signingRegion:"us-iso-east-1"},"us-gov-*/iam":"globalGovCloud","*/ce":{endpoint:"{service}.us-east-1.amazonaws.com",globalEndpoint:!0,signingRegion:"us-east-1"},"cn-*/ce":{endpoint:"{service}.cn-northwest-1.amazonaws.com.cn",globalEndpoint:!0,signingRegion:"cn-northwest-1"},"us-gov-*/sts":{endpoint:"{service}.{region}.amazonaws.com"},"us-gov-west-1/s3":"s3signature","us-west-1/s3":"s3signature","us-west-2/s3":"s3signature","eu-west-1/s3":"s3signature","ap-southeast-1/s3":"s3signature","ap-southeast-2/s3":"s3signature","ap-northeast-1/s3":"s3signature","sa-east-1/s3":"s3signature","us-east-1/s3":{endpoint:"{service}.amazonaws.com",signatureVersion:"s3"},"us-east-1/sdb":{endpoint:"{service}.amazonaws.com",signatureVersion:"v2"},"*/sdb":{endpoint:"{service}.{region}.amazonaws.com",signatureVersion:"v2"},"*/resource-explorer-2":"dualstackByDefault","*/kendra-ranking":"dualstackByDefault","*/internetmonitor":"dualstackByDefault","*/codecatalyst":"globalDualstackByDefault"},fipsRules:{"*/*":"fipsStandard","us-gov-*/*":"fipsStandard","us-iso-*/*":{endpoint:"{service}-fips.{region}.c2s.ic.gov"},"us-iso-*/dms":"usIso","us-isob-*/*":{endpoint:"{service}-fips.{region}.sc2s.sgov.gov"},"us-isob-*/dms":"usIsob","cn-*/*":{endpoint:"{service}-fips.{region}.amazonaws.com.cn"},"*/api.ecr":"fips.api.ecr","*/api.sagemaker":"fips.api.sagemaker","*/batch":"fipsDotPrefix","*/eks":"fipsDotPrefix","*/models.lex":"fips.models.lex","*/runtime.lex":"fips.runtime.lex","*/runtime.sagemaker":{endpoint:"runtime-fips.sagemaker.{region}.amazonaws.com"},"*/iam":"fipsWithoutRegion","*/route53":"fipsWithoutRegion","*/transcribe":"fipsDotPrefix","*/waf":"fipsWithoutRegion","us-gov-*/transcribe":"fipsDotPrefix","us-gov-*/api.ecr":"fips.api.ecr","us-gov-*/models.lex":"fips.models.lex","us-gov-*/runtime.lex":"fips.runtime.lex","us-gov-*/access-analyzer":"fipsWithServiceOnly","us-gov-*/acm":"fipsWithServiceOnly","us-gov-*/acm-pca":"fipsWithServiceOnly","us-gov-*/api.sagemaker":"fipsWithServiceOnly","us-gov-*/appconfig":"fipsWithServiceOnly","us-gov-*/application-autoscaling":"fipsWithServiceOnly","us-gov-*/autoscaling":"fipsWithServiceOnly","us-gov-*/autoscaling-plans":"fipsWithServiceOnly","us-gov-*/batch":"fipsWithServiceOnly","us-gov-*/cassandra":"fipsWithServiceOnly","us-gov-*/clouddirectory":"fipsWithServiceOnly","us-gov-*/cloudformation":"fipsWithServiceOnly","us-gov-*/cloudshell":"fipsWithServiceOnly","us-gov-*/cloudtrail":"fipsWithServiceOnly","us-gov-*/config":"fipsWithServiceOnly","us-gov-*/connect":"fipsWithServiceOnly","us-gov-*/databrew":"fipsWithServiceOnly","us-gov-*/dlm":"fipsWithServiceOnly","us-gov-*/dms":"fipsWithServiceOnly","us-gov-*/dynamodb":"fipsWithServiceOnly","us-gov-*/ec2":"fipsWithServiceOnly","us-gov-*/eks":"fipsWithServiceOnly","us-gov-*/elasticache":"fipsWithServiceOnly","us-gov-*/elasticbeanstalk":"fipsWithServiceOnly","us-gov-*/elasticloadbalancing":"fipsWithServiceOnly","us-gov-*/elasticmapreduce":"fipsWithServiceOnly","us-gov-*/events":"fipsWithServiceOnly","us-gov-*/fis":"fipsWithServiceOnly","us-gov-*/glacier":"fipsWithServiceOnly","us-gov-*/greengrass":"fipsWithServiceOnly","us-gov-*/guardduty":"fipsWithServiceOnly","us-gov-*/identitystore":"fipsWithServiceOnly","us-gov-*/imagebuilder":"fipsWithServiceOnly","us-gov-*/kafka":"fipsWithServiceOnly","us-gov-*/kinesis":"fipsWithServiceOnly","us-gov-*/logs":"fipsWithServiceOnly","us-gov-*/mediaconvert":"fipsWithServiceOnly","us-gov-*/monitoring":"fipsWithServiceOnly","us-gov-*/networkmanager":"fipsWithServiceOnly","us-gov-*/organizations":"fipsWithServiceOnly","us-gov-*/outposts":"fipsWithServiceOnly","us-gov-*/participant.connect":"fipsWithServiceOnly","us-gov-*/ram":"fipsWithServiceOnly","us-gov-*/rds":"fipsWithServiceOnly","us-gov-*/redshift":"fipsWithServiceOnly","us-gov-*/resource-groups":"fipsWithServiceOnly","us-gov-*/runtime.sagemaker":"fipsWithServiceOnly","us-gov-*/serverlessrepo":"fipsWithServiceOnly","us-gov-*/servicecatalog-appregistry":"fipsWithServiceOnly","us-gov-*/servicequotas":"fipsWithServiceOnly","us-gov-*/sns":"fipsWithServiceOnly","us-gov-*/sqs":"fipsWithServiceOnly","us-gov-*/ssm":"fipsWithServiceOnly","us-gov-*/streams.dynamodb":"fipsWithServiceOnly","us-gov-*/sts":"fipsWithServiceOnly","us-gov-*/support":"fipsWithServiceOnly","us-gov-*/swf":"fipsWithServiceOnly","us-gov-west-1/states":"fipsWithServiceOnly","us-iso-east-1/elasticfilesystem":{endpoint:"elasticfilesystem-fips.{region}.c2s.ic.gov"},"us-gov-west-1/organizations":"fipsWithServiceOnly","us-gov-west-1/route53":{endpoint:"route53.us-gov.amazonaws.com"},"*/resource-explorer-2":"fipsDualstackByDefault","*/kendra-ranking":"dualstackByDefault","*/internetmonitor":"dualstackByDefault","*/codecatalyst":"fipsGlobalDualstackByDefault"},dualstackRules:{"*/*":{endpoint:"{service}.{region}.api.aws"},"cn-*/*":{endpoint:"{service}.{region}.api.amazonwebservices.com.cn"},"*/s3":"dualstackLegacy","cn-*/s3":"dualstackLegacyCn","*/s3-control":"dualstackLegacy","cn-*/s3-control":"dualstackLegacyCn","ap-south-1/ec2":"dualstackLegacyEc2","eu-west-1/ec2":"dualstackLegacyEc2","sa-east-1/ec2":"dualstackLegacyEc2","us-east-1/ec2":"dualstackLegacyEc2","us-east-2/ec2":"dualstackLegacyEc2","us-west-2/ec2":"dualstackLegacyEc2"},dualstackFipsRules:{"*/*":{endpoint:"{service}-fips.{region}.api.aws"},"cn-*/*":{endpoint:"{service}-fips.{region}.api.amazonwebservices.com.cn"},"*/s3":"dualstackFipsLegacy","cn-*/s3":"dualstackFipsLegacyCn","*/s3-control":"dualstackFipsLegacy","cn-*/s3-control":"dualstackFipsLegacyCn"},patterns:{globalSSL:{endpoint:"https://{service}.amazonaws.com",globalEndpoint:!0,signingRegion:"us-east-1"},globalGovCloud:{endpoint:"{service}.us-gov.amazonaws.com",globalEndpoint:!0,signingRegion:"us-gov-west-1"},s3signature:{endpoint:"{service}.{region}.amazonaws.com",signatureVersion:"s3"},euIsoe:{endpoint:"{service}.{region}.cloud.adc-e.uk"},usIso:{endpoint:"{service}.{region}.c2s.ic.gov"},usIsob:{endpoint:"{service}.{region}.sc2s.sgov.gov"},fipsStandard:{endpoint:"{service}-fips.{region}.amazonaws.com"},fipsDotPrefix:{endpoint:"fips.{service}.{region}.amazonaws.com"},fipsWithoutRegion:{endpoint:"{service}-fips.amazonaws.com"},"fips.api.ecr":{endpoint:"ecr-fips.{region}.amazonaws.com"},"fips.api.sagemaker":{endpoint:"api-fips.sagemaker.{region}.amazonaws.com"},"fips.models.lex":{endpoint:"models-fips.lex.{region}.amazonaws.com"},"fips.runtime.lex":{endpoint:"runtime-fips.lex.{region}.amazonaws.com"},fipsWithServiceOnly:{endpoint:"{service}.{region}.amazonaws.com"},dualstackLegacy:{endpoint:"{service}.dualstack.{region}.amazonaws.com"},dualstackLegacyCn:{endpoint:"{service}.dualstack.{region}.amazonaws.com.cn"},dualstackFipsLegacy:{endpoint:"{service}-fips.dualstack.{region}.amazonaws.com"},dualstackFipsLegacyCn:{endpoint:"{service}-fips.dualstack.{region}.amazonaws.com.cn"},dualstackLegacyEc2:{endpoint:"api.ec2.{region}.aws"},dualstackByDefault:{endpoint:"{service}.{region}.api.aws"},fipsDualstackByDefault:{endpoint:"{service}-fips.{region}.api.aws"},globalDualstackByDefault:{endpoint:"{service}.global.api.aws"},fipsGlobalDualstackByDefault:{endpoint:"{service}-fips.global.api.aws"}}}},{}],58:[function(e,t,n){(function(t){(function(){var n=e("./core"),r=e("./state_machine"),o=n.util.inherit,i=n.util.domain,a=e("jmespath"),s={success:1,error:1,complete:1},c=new r;c.setupStates=function(){var e=function(e,t){var n=this;n._haltHandlersOnError=!1,n.emit(n._asm.currentState,(function(e){if(e)if(r=n,Object.prototype.hasOwnProperty.call(s,r._asm.currentState)){if(!(i&&n.domain instanceof i.Domain))throw e;e.domainEmitter=n,e.domain=n.domain,e.domainThrown=!1,n.domain.emit("error",e)}else n.response.error=e,t(e);else t(n.response.error);var r}))};this.addState("validate","build","error",e),this.addState("build","afterBuild","restart",e),this.addState("afterBuild","sign","restart",e),this.addState("sign","send","retry",e),this.addState("retry","afterRetry","afterRetry",e),this.addState("afterRetry","sign","error",e),this.addState("send","validateResponse","retry",e),this.addState("validateResponse","extractData","extractError",e),this.addState("extractError","extractData","retry",e),this.addState("extractData","success","retry",e),this.addState("restart","build","error",e),this.addState("success","complete","complete",e),this.addState("error","complete","complete",e),this.addState("complete",null,null,e)},c.setupStates(),n.Request=o({constructor:function(e,t,o){var a=e.endpoint,s=e.config.region,u=e.config.customUserAgent;e.signingRegion?s=e.signingRegion:e.isGlobalEndpoint&&(s="us-east-1"),this.domain=i&&i.active,this.service=e,this.operation=t,this.params=o||{},this.httpRequest=new n.HttpRequest(a,s),this.httpRequest.appendToUserAgent(u),this.startTime=e.getSkewCorrectedDate(),this.response=new n.Response(this),this._asm=new r(c.states,"validate"),this._haltHandlersOnError=!1,n.SequentialExecutor.call(this),this.emit=this.emitEvent},send:function(e){return e&&(this.httpRequest.appendToUserAgent("callback"),this.on("complete",(function(t){e.call(t,t.error,t.data)}))),this.runTo(),this.response},build:function(e){return this.runTo("send",e)},runTo:function(e,t){return this._asm.runTo(e,t,this),this},abort:function(){return this.removeAllListeners("validateResponse"),this.removeAllListeners("extractError"),this.on("validateResponse",(function(e){e.error=n.util.error(new Error("Request aborted by user"),{code:"RequestAbortedError",retryable:!1})})),this.httpRequest.stream&&!this.httpRequest.stream.didCallback&&(this.httpRequest.stream.abort(),this.httpRequest._abortCallback?this.httpRequest._abortCallback():this.removeAllListeners("send")),this},eachPage:function(e){e=n.util.fn.makeAsync(e,3),this.on("complete",(function t(r){e.call(r,r.error,r.data,(function(o){!1!==o&&(r.hasNextPage()?r.nextPage().on("complete",t).send():e.call(r,null,null,n.util.fn.noop))}))})).send()},eachItem:function(e){var t=this;this.eachPage((function(r,o){if(r)return e(r,null);if(null===o)return e(null,null);var i=t.service.paginationConfig(t.operation).resultKey;Array.isArray(i)&&(i=i[0]);var s=a.search(o,i),c=!0;return n.util.arrayEach(s,(function(t){if(!1===(c=e(null,t)))return n.util.abort})),c}))},isPageable:function(){return!!this.service.paginationConfig(this.operation)},createReadStream:function(){var e=n.util.stream,r=this,o=null;return 2===n.HttpClient.streamsApiVersion?(o=new e.PassThrough,t.nextTick((function(){r.send()}))):((o=new e.Stream).readable=!0,o.sent=!1,o.on("newListener",(function(e){o.sent||"data"!==e||(o.sent=!0,t.nextTick((function(){r.send()})))}))),this.on("error",(function(e){o.emit("error",e)})),this.on("httpHeaders",(function(t,i,a){if(t<300){r.removeListener("httpData",n.EventListeners.Core.HTTP_DATA),r.removeListener("httpError",n.EventListeners.Core.HTTP_ERROR),r.on("httpError",(function(e){a.error=e,a.error.retryable=!1}));var s,c=!1;if("HEAD"!==r.httpRequest.method&&(s=parseInt(i["content-length"],10)),void 0!==s&&!isNaN(s)&&s>=0){c=!0;var u=0}var l=function(){c&&u!==s?o.emit("error",n.util.error(new Error("Stream content length mismatch. Received "+u+" of "+s+" bytes."),{code:"StreamContentLengthMismatch"})):2===n.HttpClient.streamsApiVersion?o.end():o.emit("end")},p=a.httpResponse.createUnbufferedStream();if(2===n.HttpClient.streamsApiVersion)if(c){var d=new e.PassThrough;d._write=function(t){return t&&t.length&&(u+=t.length),e.PassThrough.prototype._write.apply(this,arguments)},d.on("end",l),o.on("error",(function(e){c=!1,p.unpipe(d),d.emit("end"),d.end()})),p.pipe(d).pipe(o,{end:!1})}else p.pipe(o);else c&&p.on("data",(function(e){e&&e.length&&(u+=e.length)})),p.on("data",(function(e){o.emit("data",e)})),p.on("end",l);p.on("error",(function(e){c=!1,o.emit("error",e)}))}})),o},emitEvent:function(e,t,r){"function"==typeof t&&(r=t,t=null),r||(r=function(){}),t||(t=this.eventParameters(e,this.response)),n.SequentialExecutor.prototype.emit.call(this,e,t,(function(e){e&&(this.response.error=e),r.call(this,e)}))},eventParameters:function(e){switch(e){case"restart":case"validate":case"sign":case"build":case"afterValidate":case"afterBuild":return[this];case"error":return[this.response.error,this.response];default:return[this.response]}},presign:function(e,t){return t||"function"!=typeof e||(t=e,e=null),(new n.Signers.Presign).sign(this.toGet(),e,t)},isPresigned:function(){return Object.prototype.hasOwnProperty.call(this.httpRequest.headers,"presigned-expires")},toUnauthenticated:function(){return this._unAuthenticated=!0,this.removeListener("validate",n.EventListeners.Core.VALIDATE_CREDENTIALS),this.removeListener("sign",n.EventListeners.Core.SIGN),this},toGet:function(){return"query"!==this.service.api.protocol&&"ec2"!==this.service.api.protocol||(this.removeListener("build",this.buildAsGet),this.addListener("build",this.buildAsGet)),this},buildAsGet:function(e){e.httpRequest.method="GET",e.httpRequest.path=e.service.endpoint.path+"?"+e.httpRequest.body,e.httpRequest.body="",delete e.httpRequest.headers["Content-Length"],delete e.httpRequest.headers["Content-Type"]},haltHandlersOnError:function(){this._haltHandlersOnError=!0}}),n.Request.addPromisesToClass=function(e){this.prototype.promise=function(){var t=this;return this.httpRequest.appendToUserAgent("promise"),new e((function(e,n){t.on("complete",(function(t){t.error?n(t.error):e(Object.defineProperty(t.data||{},"$response",{value:t}))})),t.runTo()}))}},n.Request.deletePromisesFromClass=function(){delete this.prototype.promise},n.util.addPromises(n.Request),n.util.mixin(n.Request,n.SequentialExecutor)}).call(this)}).call(this,e("_process"))},{"./core":19,"./state_machine":73,_process:91,jmespath:90}],59:[function(e,t,n){var r=e("./core"),o=r.util.inherit,i=e("jmespath");function a(e){var t=e.request._waiter,n=t.config.acceptors,r=!1,o="retry";n.forEach((function(n){if(!r){var i=t.matchers[n.matcher];i&&i(e,n.expected,n.argument)&&(r=!0,o=n.state)}})),!r&&e.error&&(o="failure"),"success"===o?t.setSuccess(e):t.setError(e,"retry"===o)}r.ResourceWaiter=o({constructor:function(e,t){this.service=e,this.state=t,this.loadWaiterConfig(this.state)},service:null,state:null,config:null,matchers:{path:function(e,t,n){try{var r=i.search(e.data,n)}catch(e){return!1}return i.strictDeepEqual(r,t)},pathAll:function(e,t,n){try{var r=i.search(e.data,n)}catch(e){return!1}Array.isArray(r)||(r=[r]);var o=r.length;if(!o)return!1;for(var a=0;a<o;a++)if(!i.strictDeepEqual(r[a],t))return!1;return!0},pathAny:function(e,t,n){try{var r=i.search(e.data,n)}catch(e){return!1}Array.isArray(r)||(r=[r]);for(var o=r.length,a=0;a<o;a++)if(i.strictDeepEqual(r[a],t))return!0;return!1},status:function(e,t){var n=e.httpResponse.statusCode;return"number"==typeof n&&n===t},error:function(e,t){return"string"==typeof t&&e.error?t===e.error.code:t===!!e.error}},listeners:(new r.SequentialExecutor).addNamedListeners((function(e){e("RETRY_CHECK","retry",(function(e){var t=e.request._waiter;e.error&&"ResourceNotReady"===e.error.code&&(e.error.retryDelay=1e3*(t.config.delay||0))})),e("CHECK_OUTPUT","extractData",a),e("CHECK_ERROR","extractError",a)})),wait:function(e,t){"function"==typeof e&&(t=e,e=void 0),e&&e.$waiter&&("number"==typeof(e=r.util.copy(e)).$waiter.delay&&(this.config.delay=e.$waiter.delay),"number"==typeof e.$waiter.maxAttempts&&(this.config.maxAttempts=e.$waiter.maxAttempts),delete e.$waiter);var n=this.service.makeRequest(this.config.operation,e);return n._waiter=this,n.response.maxRetries=this.config.maxAttempts,n.addListeners(this.listeners),t&&n.send(t),n},setSuccess:function(e){e.error=null,e.data=e.data||{},e.request.removeAllListeners("extractData")},setError:function(e,t){e.data=null,e.error=r.util.error(e.error||new Error,{code:"ResourceNotReady",message:"Resource is not in the state "+this.state,retryable:t})},loadWaiterConfig:function(e){if(!this.service.api.waiters[e])throw new r.util.error(new Error,{code:"StateNotFoundError",message:"State "+e+" not found."});this.config=r.util.copy(this.service.api.waiters[e])}})},{"./core":19,jmespath:90}],60:[function(e,t,n){var r=e("./core"),o=r.util.inherit,i=e("jmespath");r.Response=o({constructor:function(e){this.request=e,this.data=null,this.error=null,this.retryCount=0,this.redirectCount=0,this.httpResponse=new r.HttpResponse,e&&(this.maxRetries=e.service.numRetries(),this.maxRedirects=e.service.config.maxRedirects)},nextPage:function(e){var t,n=this.request.service,o=this.request.operation;try{t=n.paginationConfig(o,!0)}catch(e){this.error=e}if(!this.hasNextPage()){if(e)e(this.error,null);else if(this.error)throw this.error;return null}var i=r.util.copy(this.request.params);if(this.nextPageTokens){var a=t.inputToken;"string"==typeof a&&(a=[a]);for(var s=0;s<a.length;s++)i[a[s]]=this.nextPageTokens[s];return n.makeRequest(this.request.operation,i,e)}return e?e(null,null):null},hasNextPage:function(){return this.cacheNextPageTokens(),!!this.nextPageTokens||void 0===this.nextPageTokens&&void 0},cacheNextPageTokens:function(){if(Object.prototype.hasOwnProperty.call(this,"nextPageTokens"))return this.nextPageTokens;this.nextPageTokens=void 0;var e=this.request.service.paginationConfig(this.request.operation);if(!e)return this.nextPageTokens;if(this.nextPageTokens=null,e.moreResults&&!i.search(this.data,e.moreResults))return this.nextPageTokens;var t=e.outputToken;return"string"==typeof t&&(t=[t]),r.util.arrayEach.call(this,t,(function(e){var t=i.search(this.data,e);t&&(this.nextPageTokens=this.nextPageTokens||[],this.nextPageTokens.push(t))})),this.nextPageTokens}})},{"./core":19,jmespath:90}],61:[function(e,t,n){var r=e("./core");r.SequentialExecutor=r.util.inherit({constructor:function(){this._events={}},listeners:function(e){return this._events[e]?this._events[e].slice(0):[]},on:function(e,t,n){return this._events[e]?n?this._events[e].unshift(t):this._events[e].push(t):this._events[e]=[t],this},onAsync:function(e,t,n){return t._isAsync=!0,this.on(e,t,n)},removeListener:function(e,t){var n=this._events[e];if(n){for(var r=n.length,o=-1,i=0;i<r;++i)n[i]===t&&(o=i);o>-1&&n.splice(o,1)}return this},removeAllListeners:function(e){return e?delete this._events[e]:this._events={},this},emit:function(e,t,n){n||(n=function(){});var r=this.listeners(e),o=r.length;return this.callListeners(r,t,n),o>0},callListeners:function(e,t,n,o){var i=this,a=o||null;function s(o){if(o&&(a=r.util.error(a||new Error,o),i._haltHandlersOnError))return n.call(i,a);i.callListeners(e,t,n,a)}for(;e.length>0;){var c=e.shift();if(c._isAsync)return void c.apply(i,t.concat([s]));try{c.apply(i,t)}catch(e){a=r.util.error(a||new Error,e)}if(a&&i._haltHandlersOnError)return void n.call(i,a)}n.call(i,a)},addListeners:function(e){var t=this;return e._events&&(e=e._events),r.util.each(e,(function(e,n){"function"==typeof n&&(n=[n]),r.util.arrayEach(n,(function(n){t.on(e,n)}))})),t},addNamedListener:function(e,t,n,r){return this[e]=n,this.addListener(t,n,r),this},addNamedAsyncListener:function(e,t,n,r){return n._isAsync=!0,this.addNamedListener(e,t,n,r)},addNamedListeners:function(e){var t=this;return e((function(){t.addNamedListener.apply(t,arguments)}),(function(){t.addNamedAsyncListener.apply(t,arguments)})),this}}),r.SequentialExecutor.prototype.addListener=r.SequentialExecutor.prototype.on,t.exports=r.SequentialExecutor},{"./core":19}],62:[function(e,t,n){(function(n){(function(){var r=e("./core"),i=e("./model/api"),a=e("./region_config"),s=r.util.inherit,c=0,u=e("./region/utils");r.Service=s({constructor:function(e){if(!this.loadServiceClass)throw r.util.error(new Error,"Service must be constructed with `new' operator");if(e){if(e.region){var t=e.region;u.isFipsRegion(t)&&(e.region=u.getRealRegion(t),e.useFipsEndpoint=!0),u.isGlobalRegion(t)&&(e.region=u.getRealRegion(t))}"boolean"==typeof e.useDualstack&&"boolean"!=typeof e.useDualstackEndpoint&&(e.useDualstackEndpoint=e.useDualstack)}var n=this.loadServiceClass(e||{});if(n){var o=r.util.copy(e),i=new n(e);return Object.defineProperty(i,"_originalConfig",{get:function(){return o},enumerable:!1,configurable:!0}),i._clientId=++c,i}this.initialize(e)},initialize:function(e){var t=r.config[this.serviceIdentifier];if(this.config=new r.Config(r.config),t&&this.config.update(t,!0),e&&this.config.update(e,!0),this.validateService(),this.config.endpoint||a.configureEndpoint(this),this.config.endpoint=this.endpointFromTemplate(this.config.endpoint),this.setEndpoint(this.config.endpoint),r.SequentialExecutor.call(this),r.Service.addDefaultMonitoringListeners(this),(this.config.clientSideMonitoring||r.Service._clientSideMonitoring)&&this.publisher){var o=this.publisher;this.addNamedListener("PUBLISH_API_CALL","apiCall",(function(e){n.nextTick((function(){o.eventHandler(e)}))})),this.addNamedListener("PUBLISH_API_ATTEMPT","apiCallAttempt",(function(e){n.nextTick((function(){o.eventHandler(e)}))}))}},validateService:function(){},loadServiceClass:function(e){var t=e;if(r.util.isEmpty(this.api)){if(t.apiConfig)return r.Service.defineServiceApi(this.constructor,t.apiConfig);if(this.constructor.services){(t=new r.Config(r.config)).update(e,!0);var n=t.apiVersions[this.constructor.serviceIdentifier];return n=n||t.apiVersion,this.getLatestServiceClass(n)}return null}return null},getLatestServiceClass:function(e){return e=this.getLatestServiceVersion(e),null===this.constructor.services[e]&&r.Service.defineServiceApi(this.constructor,e),this.constructor.services[e]},getLatestServiceVersion:function(e){if(!this.constructor.services||0===this.constructor.services.length)throw new Error("No services defined on "+this.constructor.serviceIdentifier);if(e?r.util.isType(e,Date)&&(e=r.util.date.iso8601(e).split("T")[0]):e="latest",Object.hasOwnProperty(this.constructor.services,e))return e;for(var t=Object.keys(this.constructor.services).sort(),n=null,o=t.length-1;o>=0;o--)if("*"!==t[o][t[o].length-1]&&(n=t[o]),t[o].substr(0,10)<=e)return n;throw new Error("Could not find "+this.constructor.serviceIdentifier+" API to satisfy version constraint `"+e+"'")},api:{},defaultRetryCount:3,customizeRequests:function(e){if(e){if("function"!=typeof e)throw new Error("Invalid callback type '"+o(e)+"' provided in customizeRequests");this.customRequestHandler=e}else this.customRequestHandler=null},makeRequest:function(e,t,n){if("function"==typeof t&&(n=t,t=null),t=t||{},this.config.params){var o=this.api.operations[e];o&&(t=r.util.copy(t),r.util.each(this.config.params,(function(e,n){o.input.members[e]&&(void 0!==t[e]&&null!==t[e]||(t[e]=n))})))}var i=new r.Request(this,e,t);return this.addAllRequestListeners(i),this.attachMonitoringEmitter(i),n&&i.send(n),i},makeUnauthenticatedRequest:function(e,t,n){"function"==typeof t&&(n=t,t={});var r=this.makeRequest(e,t).toUnauthenticated();return n?r.send(n):r},waitFor:function(e,t,n){return new r.ResourceWaiter(this,e).wait(t,n)},addAllRequestListeners:function(e){for(var t=[r.events,r.EventListeners.Core,this.serviceInterface(),r.EventListeners.CorePost],n=0;n<t.length;n++)t[n]&&e.addListeners(t[n]);this.config.paramValidation||e.removeListener("validate",r.EventListeners.Core.VALIDATE_PARAMETERS),this.config.logger&&e.addListeners(r.EventListeners.Logger),this.setupRequestListeners(e),"function"==typeof this.constructor.prototype.customRequestHandler&&this.constructor.prototype.customRequestHandler(e),Object.prototype.hasOwnProperty.call(this,"customRequestHandler")&&"function"==typeof this.customRequestHandler&&this.customRequestHandler(e)},apiCallEvent:function(e){var t=e.service.api.operations[e.operation],n={Type:"ApiCall",Api:t?t.name:e.operation,Version:1,Service:e.service.api.serviceId||e.service.api.endpointPrefix,Region:e.httpRequest.region,MaxRetriesExceeded:0,UserAgent:e.httpRequest.getUserAgent()},r=e.response;if(r.httpResponse.statusCode&&(n.FinalHttpStatusCode=r.httpResponse.statusCode),r.error){var o=r.error;r.httpResponse.statusCode>299?(o.code&&(n.FinalAwsException=o.code),o.message&&(n.FinalAwsExceptionMessage=o.message)):((o.code||o.name)&&(n.FinalSdkException=o.code||o.name),o.message&&(n.FinalSdkExceptionMessage=o.message))}return n},apiAttemptEvent:function(e){var t=e.service.api.operations[e.operation],n={Type:"ApiCallAttempt",Api:t?t.name:e.operation,Version:1,Service:e.service.api.serviceId||e.service.api.endpointPrefix,Fqdn:e.httpRequest.endpoint.hostname,UserAgent:e.httpRequest.getUserAgent()},r=e.response;return r.httpResponse.statusCode&&(n.HttpStatusCode=r.httpResponse.statusCode),!e._unAuthenticated&&e.service.config.credentials&&e.service.config.credentials.accessKeyId&&(n.AccessKey=e.service.config.credentials.accessKeyId),r.httpResponse.headers?(e.httpRequest.headers["x-amz-security-token"]&&(n.SessionToken=e.httpRequest.headers["x-amz-security-token"]),r.httpResponse.headers["x-amzn-requestid"]&&(n.XAmznRequestId=r.httpResponse.headers["x-amzn-requestid"]),r.httpResponse.headers["x-amz-request-id"]&&(n.XAmzRequestId=r.httpResponse.headers["x-amz-request-id"]),r.httpResponse.headers["x-amz-id-2"]&&(n.XAmzId2=r.httpResponse.headers["x-amz-id-2"]),n):n},attemptFailEvent:function(e){var t=this.apiAttemptEvent(e),n=e.response,r=n.error;return n.httpResponse.statusCode>299?(r.code&&(t.AwsException=r.code),r.message&&(t.AwsExceptionMessage=r.message)):((r.code||r.name)&&(t.SdkException=r.code||r.name),r.message&&(t.SdkExceptionMessage=r.message)),t},attachMonitoringEmitter:function(e){var t,n,o,i,a,s,c=0,u=this,l=!0;e.on("validate",(function(){i=r.util.realClock.now(),s=Date.now()}),l),e.on("sign",(function(){n=r.util.realClock.now(),t=Date.now(),a=e.httpRequest.region,c++}),l),e.on("validateResponse",(function(){o=Math.round(r.util.realClock.now()-n)})),e.addNamedListener("API_CALL_ATTEMPT","success",(function(){var n=u.apiAttemptEvent(e);n.Timestamp=t,n.AttemptLatency=o>=0?o:0,n.Region=a,u.emit("apiCallAttempt",[n])})),e.addNamedListener("API_CALL_ATTEMPT_RETRY","retry",(function(){var i=u.attemptFailEvent(e);i.Timestamp=t,o=o||Math.round(r.util.realClock.now()-n),i.AttemptLatency=o>=0?o:0,i.Region=a,u.emit("apiCallAttempt",[i])})),e.addNamedListener("API_CALL","complete",(function(){var t=u.apiCallEvent(e);if(t.AttemptCount=c,!(t.AttemptCount<=0)){t.Timestamp=s;var n=Math.round(r.util.realClock.now()-i);t.Latency=n>=0?n:0;var o=e.response;o.error&&o.error.retryable&&"number"==typeof o.retryCount&&"number"==typeof o.maxRetries&&o.retryCount>=o.maxRetries&&(t.MaxRetriesExceeded=1),u.emit("apiCall",[t])}}))},setupRequestListeners:function(e){},getSigningName:function(){return this.api.signingName||this.api.endpointPrefix},getSignerClass:function(e){var t,n=null,o="";return e&&(o=(n=(e.service.api.operations||{})[e.operation]||null)?n.authtype:""),t=this.config.signatureVersion?this.config.signatureVersion:"v4"===o||"v4-unsigned-body"===o?"v4":"bearer"===o?"bearer":this.api.signatureVersion,r.Signers.RequestSigner.getVersion(t)},serviceInterface:function(){switch(this.api.protocol){case"ec2":case"query":return r.EventListeners.Query;case"json":return r.EventListeners.Json;case"rest-json":return r.EventListeners.RestJson;case"rest-xml":return r.EventListeners.RestXml}if(this.api.protocol)throw new Error("Invalid service `protocol' "+this.api.protocol+" in API config")},successfulResponse:function(e){return e.httpResponse.statusCode<300},numRetries:function(){return void 0!==this.config.maxRetries?this.config.maxRetries:this.defaultRetryCount},retryDelays:function(e,t){return r.util.calculateRetryDelay(e,this.config.retryDelayOptions,t)},retryableError:function(e){return!!this.timeoutError(e)||!!this.networkingError(e)||!!this.expiredCredentialsError(e)||!!this.throttledError(e)||e.statusCode>=500},networkingError:function(e){return"NetworkingError"===e.code},timeoutError:function(e){return"TimeoutError"===e.code},expiredCredentialsError:function(e){return"ExpiredTokenException"===e.code},clockSkewError:function(e){switch(e.code){case"RequestTimeTooSkewed":case"RequestExpired":case"InvalidSignatureException":case"SignatureDoesNotMatch":case"AuthFailure":case"RequestInTheFuture":return!0;default:return!1}},getSkewCorrectedDate:function(){return new Date(Date.now()+this.config.systemClockOffset)},applyClockOffset:function(e){e&&(this.config.systemClockOffset=e-Date.now())},isClockSkewed:function(e){if(e)return Math.abs(this.getSkewCorrectedDate().getTime()-e)>=3e5},throttledError:function(e){if(429===e.statusCode)return!0;switch(e.code){case"ProvisionedThroughputExceededException":case"Throttling":case"ThrottlingException":case"RequestLimitExceeded":case"RequestThrottled":case"RequestThrottledException":case"TooManyRequestsException":case"TransactionInProgressException":case"EC2ThrottledException":return!0;default:return!1}},endpointFromTemplate:function(e){if("string"!=typeof e)return e;var t=e;return t=(t=(t=t.replace(/\{service\}/g,this.api.endpointPrefix)).replace(/\{region\}/g,this.config.region)).replace(/\{scheme\}/g,this.config.sslEnabled?"https":"http")},setEndpoint:function(e){this.endpoint=new r.Endpoint(e,this.config)},paginationConfig:function(e,t){var n=this.api.operations[e].paginator;if(!n){if(t){var o=new Error;throw r.util.error(o,"No pagination configuration for "+e)}return null}return n}}),r.util.update(r.Service,{defineMethods:function(e){r.util.each(e.prototype.api.operations,(function(t){e.prototype[t]||("none"===e.prototype.api.operations[t].authtype?e.prototype[t]=function(e,n){return this.makeUnauthenticatedRequest(t,e,n)}:e.prototype[t]=function(e,n){return this.makeRequest(t,e,n)})}))},defineService:function(e,t,n){r.Service._serviceMap[e]=!0,Array.isArray(t)||(n=t,t=[]);var o=s(r.Service,n||{});if("string"==typeof e){r.Service.addVersions(o,t);var i=o.serviceIdentifier||e;o.serviceIdentifier=i}else o.prototype.api=e,r.Service.defineMethods(o);if(r.SequentialExecutor.call(this.prototype),!this.prototype.publisher&&r.util.clientSideMonitoring){var a=r.util.clientSideMonitoring.Publisher,c=(0,r.util.clientSideMonitoring.configProvider)();this.prototype.publisher=new a(c),c.enabled&&(r.Service._clientSideMonitoring=!0)}return r.SequentialExecutor.call(o.prototype),r.Service.addDefaultMonitoringListeners(o.prototype),o},addVersions:function(e,t){Array.isArray(t)||(t=[t]),e.services=e.services||{};for(var n=0;n<t.length;n++)void 0===e.services[t[n]]&&(e.services[t[n]]=null);e.apiVersions=Object.keys(e.services).sort()},defineServiceApi:function(e,t,n){var o=s(e,{serviceIdentifier:e.serviceIdentifier});function a(t){t.isApi?o.prototype.api=t:o.prototype.api=new i(t,{serviceIdentifier:e.serviceIdentifier})}if("string"==typeof t){if(n)a(n);else try{a(r.apiLoader(e.serviceIdentifier,t))}catch(n){throw r.util.error(n,{message:"Could not find API configuration "+e.serviceIdentifier+"-"+t})}Object.prototype.hasOwnProperty.call(e.services,t)||(e.apiVersions=e.apiVersions.concat(t).sort()),e.services[t]=o}else a(t);return r.Service.defineMethods(o),o},hasService:function(e){return Object.prototype.hasOwnProperty.call(r.Service._serviceMap,e)},addDefaultMonitoringListeners:function(e){e.addNamedListener("MONITOR_EVENTS_BUBBLE","apiCallAttempt",(function(t){var n=Object.getPrototypeOf(e);n._events&&n.emit("apiCallAttempt",[t])})),e.addNamedListener("CALL_EVENTS_BUBBLE","apiCall",(function(t){var n=Object.getPrototypeOf(e);n._events&&n.emit("apiCall",[t])}))},_serviceMap:{}}),r.util.mixin(r.Service,r.SequentialExecutor),t.exports=r.Service}).call(this)}).call(this,e("_process"))},{"./core":19,"./model/api":40,"./region/utils":55,"./region_config":56,_process:91}],63:[function(e,t,n){var r=e("../core"),o=e("../config_regional_endpoint");r.util.update(r.STS.prototype,{credentialsFrom:function(e,t){return e?(t||(t=new r.TemporaryCredentials),t.expired=!1,t.accessKeyId=e.Credentials.AccessKeyId,t.secretAccessKey=e.Credentials.SecretAccessKey,t.sessionToken=e.Credentials.SessionToken,t.expireTime=e.Credentials.Expiration,t):null},assumeRoleWithWebIdentity:function(e,t){return this.makeUnauthenticatedRequest("assumeRoleWithWebIdentity",e,t)},assumeRoleWithSAML:function(e,t){return this.makeUnauthenticatedRequest("assumeRoleWithSAML",e,t)},setupRequestListeners:function(e){e.addListener("validate",this.optInRegionalEndpoint,!0)},optInRegionalEndpoint:function(e){var t=e.service,n=t.config;if(n.stsRegionalEndpoints=o(t._originalConfig,{env:"AWS_STS_REGIONAL_ENDPOINTS",sharedConfig:"sts_regional_endpoints",clientConfig:"stsRegionalEndpoints"}),"regional"===n.stsRegionalEndpoints&&t.isGlobalEndpoint){if(!n.region)throw r.util.error(new Error,{code:"ConfigError",message:"Missing region in config"});var i=n.endpoint.indexOf(".amazonaws.com"),a=n.endpoint.substring(0,i)+"."+n.region+n.endpoint.substring(i);e.httpRequest.updateEndpoint(a),e.httpRequest.region=n.region}}})},{"../config_regional_endpoint":18,"../core":19}],64:[function(e,t,n){var r=e("../core");r.Signers.Bearer=r.util.inherit(r.Signers.RequestSigner,{constructor:function(e){r.Signers.RequestSigner.call(this,e)},addAuthorization:function(e){this.request.headers.Authorization="Bearer "+e.token}})},{"../core":19}],65:[function(e,t,n){var r=e("../core"),o=r.util.inherit,i="presigned-expires";function a(e){var t=e.httpRequest.headers[i],n=e.service.getSignerClass(e);if(delete e.httpRequest.headers["User-Agent"],delete e.httpRequest.headers["X-Amz-User-Agent"],n===r.Signers.V4){if(t>604800)throw r.util.error(new Error,{code:"InvalidExpiryTime",message:"Presigning does not support expiry time greater than a week with SigV4 signing.",retryable:!1});e.httpRequest.headers[i]=t}else{if(n!==r.Signers.S3)throw r.util.error(new Error,{message:"Presigning only supports S3 or SigV4 signing.",code:"UnsupportedSigner",retryable:!1});var o=e.service?e.service.getSkewCorrectedDate():r.util.date.getDate();e.httpRequest.headers[i]=parseInt(r.util.date.unixTimestamp(o)+t,10).toString()}}function s(e){var t=e.httpRequest.endpoint,n=r.util.urlParse(e.httpRequest.path),o={};n.search&&(o=r.util.queryStringParse(n.search.substr(1)));var a=e.httpRequest.headers.Authorization.split(" ");if("AWS"===a[0])a=a[1].split(":"),o.Signature=a.pop(),o.AWSAccessKeyId=a.join(":"),r.util.each(e.httpRequest.headers,(function(e,t){e===i&&(e="Expires"),0===e.indexOf("x-amz-meta-")&&(delete o[e],e=e.toLowerCase()),o[e]=t})),delete e.httpRequest.headers[i],delete o.Authorization,delete o.Host;else if("AWS4-HMAC-SHA256"===a[0]){a.shift();var s=a.join(" ").match(/Signature=(.*?)(?:,|\s|\r?\n|$)/)[1];o["X-Amz-Signature"]=s,delete o.Expires}t.pathname=n.pathname,t.search=r.util.queryParamsToString(o)}r.Signers.Presign=o({sign:function(e,t,n){if(e.httpRequest.headers[i]=t||3600,e.on("build",a),e.on("sign",s),e.removeListener("afterBuild",r.EventListeners.Core.SET_CONTENT_LENGTH),e.removeListener("afterBuild",r.EventListeners.Core.COMPUTE_SHA256),e.emit("beforePresign",[e]),!n){if(e.build(),e.response.error)throw e.response.error;return r.util.urlFormat(e.httpRequest.endpoint)}e.build((function(){this.response.error?n(this.response.error):n(null,r.util.urlFormat(e.httpRequest.endpoint))}))}}),t.exports=r.Signers.Presign},{"../core":19}],66:[function(e,t,n){var r=e("../core"),o=r.util.inherit;r.Signers.RequestSigner=o({constructor:function(e){this.request=e},setServiceClientId:function(e){this.serviceClientId=e},getServiceClientId:function(){return this.serviceClientId}}),r.Signers.RequestSigner.getVersion=function(e){switch(e){case"v2":return r.Signers.V2;case"v3":return r.Signers.V3;case"s3v4":case"v4":return r.Signers.V4;case"s3":return r.Signers.S3;case"v3https":return r.Signers.V3Https;case"bearer":return r.Signers.Bearer}throw new Error("Unknown signing version "+e)},e("./v2"),e("./v3"),e("./v3https"),e("./v4"),e("./s3"),e("./presign"),e("./bearer")},{"../core":19,"./bearer":64,"./presign":65,"./s3":67,"./v2":68,"./v3":69,"./v3https":70,"./v4":71}],67:[function(e,t,n){var r=e("../core"),o=r.util.inherit;r.Signers.S3=o(r.Signers.RequestSigner,{subResources:{acl:1,accelerate:1,analytics:1,cors:1,lifecycle:1,delete:1,inventory:1,location:1,logging:1,metrics:1,notification:1,partNumber:1,policy:1,requestPayment:1,replication:1,restore:1,tagging:1,torrent:1,uploadId:1,uploads:1,versionId:1,versioning:1,versions:1,website:1},responseHeaders:{"response-content-type":1,"response-content-language":1,"response-expires":1,"response-cache-control":1,"response-content-disposition":1,"response-content-encoding":1},addAuthorization:function(e,t){this.request.headers["presigned-expires"]||(this.request.headers["X-Amz-Date"]=r.util.date.rfc822(t)),e.sessionToken&&(this.request.headers["x-amz-security-token"]=e.sessionToken);var n=this.sign(e.secretAccessKey,this.stringToSign()),o="AWS "+e.accessKeyId+":"+n;this.request.headers.Authorization=o},stringToSign:function(){var e=this.request,t=[];t.push(e.method),t.push(e.headers["Content-MD5"]||""),t.push(e.headers["Content-Type"]||""),t.push(e.headers["presigned-expires"]||"");var n=this.canonicalizedAmzHeaders();return n&&t.push(n),t.push(this.canonicalizedResource()),t.join("\n")},canonicalizedAmzHeaders:function(){var e=[];r.util.each(this.request.headers,(function(t){t.match(/^x-amz-/i)&&e.push(t)})),e.sort((function(e,t){return e.toLowerCase()<t.toLowerCase()?-1:1}));var t=[];return r.util.arrayEach.call(this,e,(function(e){t.push(e.toLowerCase()+":"+String(this.request.headers[e]))})),t.join("\n")},canonicalizedResource:function(){var e=this.request,t=e.path.split("?"),n=t[0],o=t[1],i="";if(e.virtualHostedBucket&&(i+="/"+e.virtualHostedBucket),i+=n,o){var a=[];r.util.arrayEach.call(this,o.split("&"),(function(e){var t=e.split("=")[0],n=e.split("=")[1];if(this.subResources[t]||this.responseHeaders[t]){var r={name:t};void 0!==n&&(this.subResources[t]?r.value=n:r.value=decodeURIComponent(n)),a.push(r)}})),a.sort((function(e,t){return e.name<t.name?-1:1})),a.length&&(o=[],r.util.arrayEach(a,(function(e){void 0===e.value?o.push(e.name):o.push(e.name+"="+e.value)})),i+="?"+o.join("&"))}return i},sign:function(e,t){return r.util.crypto.hmac(e,t,"base64","sha1")}}),t.exports=r.Signers.S3},{"../core":19}],68:[function(e,t,n){var r=e("../core"),o=r.util.inherit;r.Signers.V2=o(r.Signers.RequestSigner,{addAuthorization:function(e,t){t||(t=r.util.date.getDate());var n=this.request;n.params.Timestamp=r.util.date.iso8601(t),n.params.SignatureVersion="2",n.params.SignatureMethod="HmacSHA256",n.params.AWSAccessKeyId=e.accessKeyId,e.sessionToken&&(n.params.SecurityToken=e.sessionToken),delete n.params.Signature,n.params.Signature=this.signature(e),n.body=r.util.queryParamsToString(n.params),n.headers["Content-Length"]=n.body.length},signature:function(e){return r.util.crypto.hmac(e.secretAccessKey,this.stringToSign(),"base64")},stringToSign:function(){var e=[];return e.push(this.request.method),e.push(this.request.endpoint.host.toLowerCase()),e.push(this.request.pathname()),e.push(r.util.queryParamsToString(this.request.params)),e.join("\n")}}),t.exports=r.Signers.V2},{"../core":19}],69:[function(e,t,n){var r=e("../core"),o=r.util.inherit;r.Signers.V3=o(r.Signers.RequestSigner,{addAuthorization:function(e,t){var n=r.util.date.rfc822(t);this.request.headers["X-Amz-Date"]=n,e.sessionToken&&(this.request.headers["x-amz-security-token"]=e.sessionToken),this.request.headers["X-Amzn-Authorization"]=this.authorization(e,n)},authorization:function(e){return"AWS3 AWSAccessKeyId="+e.accessKeyId+",Algorithm=HmacSHA256,SignedHeaders="+this.signedHeaders()+",Signature="+this.signature(e)},signedHeaders:function(){var e=[];return r.util.arrayEach(this.headersToSign(),(function(t){e.push(t.toLowerCase())})),e.sort().join(";")},canonicalHeaders:function(){var e=this.request.headers,t=[];return r.util.arrayEach(this.headersToSign(),(function(n){t.push(n.toLowerCase().trim()+":"+String(e[n]).trim())})),t.sort().join("\n")+"\n"},headersToSign:function(){var e=[];return r.util.each(this.request.headers,(function(t){("Host"===t||"Content-Encoding"===t||t.match(/^X-Amz/i))&&e.push(t)})),e},signature:function(e){return r.util.crypto.hmac(e.secretAccessKey,this.stringToSign(),"base64")},stringToSign:function(){var e=[];return e.push(this.request.method),e.push("/"),e.push(""),e.push(this.canonicalHeaders()),e.push(this.request.body),r.util.crypto.sha256(e.join("\n"))}}),t.exports=r.Signers.V3},{"../core":19}],70:[function(e,t,n){var r=e("../core"),o=r.util.inherit;e("./v3"),r.Signers.V3Https=o(r.Signers.V3,{authorization:function(e){return"AWS3-HTTPS AWSAccessKeyId="+e.accessKeyId+",Algorithm=HmacSHA256,Signature="+this.signature(e)},stringToSign:function(){return this.request.headers["X-Amz-Date"]}}),t.exports=r.Signers.V3Https},{"../core":19,"./v3":69}],71:[function(e,t,n){var r=e("../core"),o=e("./v4_credentials"),i=r.util.inherit,a="presigned-expires";r.Signers.V4=i(r.Signers.RequestSigner,{constructor:function(e,t,n){r.Signers.RequestSigner.call(this,e),this.serviceName=t,n=n||{},this.signatureCache="boolean"!=typeof n.signatureCache||n.signatureCache,this.operation=n.operation,this.signatureVersion=n.signatureVersion},algorithm:"AWS4-HMAC-SHA256",addAuthorization:function(e,t){var n=r.util.date.iso8601(t).replace(/[:\-]|\.\d{3}/g,"");this.isPresigned()?this.updateForPresigned(e,n):this.addHeaders(e,n),this.request.headers.Authorization=this.authorization(e,n)},addHeaders:function(e,t){this.request.headers["X-Amz-Date"]=t,e.sessionToken&&(this.request.headers["x-amz-security-token"]=e.sessionToken)},updateForPresigned:function(e,t){var n=this.credentialString(t),o={"X-Amz-Date":t,"X-Amz-Algorithm":this.algorithm,"X-Amz-Credential":e.accessKeyId+"/"+n,"X-Amz-Expires":this.request.headers[a],"X-Amz-SignedHeaders":this.signedHeaders()};e.sessionToken&&(o["X-Amz-Security-Token"]=e.sessionToken),this.request.headers["Content-Type"]&&(o["Content-Type"]=this.request.headers["Content-Type"]),this.request.headers["Content-MD5"]&&(o["Content-MD5"]=this.request.headers["Content-MD5"]),this.request.headers["Cache-Control"]&&(o["Cache-Control"]=this.request.headers["Cache-Control"]),r.util.each.call(this,this.request.headers,(function(e,t){if(e!==a&&this.isSignableHeader(e)){var n=e.toLowerCase();0===n.indexOf("x-amz-meta-")?o[n]=t:0===n.indexOf("x-amz-")&&(o[e]=t)}}));var i=this.request.path.indexOf("?")>=0?"&":"?";this.request.path+=i+r.util.queryParamsToString(o)},authorization:function(e,t){var n=[],r=this.credentialString(t);return n.push(this.algorithm+" Credential="+e.accessKeyId+"/"+r),n.push("SignedHeaders="+this.signedHeaders()),n.push("Signature="+this.signature(e,t)),n.join(", ")},signature:function(e,t){var n=o.getSigningKey(e,t.substr(0,8),this.request.region,this.serviceName,this.signatureCache);return r.util.crypto.hmac(n,this.stringToSign(t),"hex")},stringToSign:function(e){var t=[];return t.push("AWS4-HMAC-SHA256"),t.push(e),t.push(this.credentialString(e)),t.push(this.hexEncodedHash(this.canonicalString())),t.join("\n")},canonicalString:function(){var e=[],t=this.request.pathname();return"s3"!==this.serviceName&&"s3v4"!==this.signatureVersion&&(t=r.util.uriEscapePath(t)),e.push(this.request.method),e.push(t),e.push(this.request.search()),e.push(this.canonicalHeaders()+"\n"),e.push(this.signedHeaders()),e.push(this.hexEncodedBodyHash()),e.join("\n")},canonicalHeaders:function(){var e=[];r.util.each.call(this,this.request.headers,(function(t,n){e.push([t,n])})),e.sort((function(e,t){return e[0].toLowerCase()<t[0].toLowerCase()?-1:1}));var t=[];return r.util.arrayEach.call(this,e,(function(e){var n=e[0].toLowerCase();if(this.isSignableHeader(n)){var o=e[1];if(null==o||"function"!=typeof o.toString)throw r.util.error(new Error("Header "+n+" contains invalid value"),{code:"InvalidHeader"});t.push(n+":"+this.canonicalHeaderValues(o.toString()))}})),t.join("\n")},canonicalHeaderValues:function(e){return e.replace(/\s+/g," ").replace(/^\s+|\s+$/g,"")},signedHeaders:function(){var e=[];return r.util.each.call(this,this.request.headers,(function(t){t=t.toLowerCase(),this.isSignableHeader(t)&&e.push(t)})),e.sort().join(";")},credentialString:function(e){return o.createScope(e.substr(0,8),this.request.region,this.serviceName)},hexEncodedHash:function(e){return r.util.crypto.sha256(e,"hex")},hexEncodedBodyHash:function(){var e=this.request;return this.isPresigned()&&["s3","s3-object-lambda"].indexOf(this.serviceName)>-1&&!e.body?"UNSIGNED-PAYLOAD":e.headers["X-Amz-Content-Sha256"]?e.headers["X-Amz-Content-Sha256"]:this.hexEncodedHash(this.request.body||"")},unsignableHeaders:["authorization","content-type","content-length","user-agent",a,"expect","x-amzn-trace-id"],isSignableHeader:function(e){return 0===e.toLowerCase().indexOf("x-amz-")||this.unsignableHeaders.indexOf(e)<0},isPresigned:function(){return!!this.request.headers[a]}}),t.exports=r.Signers.V4},{"../core":19,"./v4_credentials":72}],72:[function(e,t,n){var r=e("../core"),o={},i=[],a="aws4_request";t.exports={createScope:function(e,t,n){return[e.substr(0,8),t,n,a].join("/")},getSigningKey:function(e,t,n,s,c){var u=[r.util.crypto.hmac(e.secretAccessKey,e.accessKeyId,"base64"),t,n,s].join("_");if((c=!1!==c)&&u in o)return o[u];var l=r.util.crypto.hmac("AWS4"+e.secretAccessKey,t,"buffer"),p=r.util.crypto.hmac(l,n,"buffer"),d=r.util.crypto.hmac(p,s,"buffer"),f=r.util.crypto.hmac(d,a,"buffer");return c&&(o[u]=f,i.push(u),i.length>50&&delete o[i.shift()]),f},emptyCache:function(){o={},i=[]}}},{"../core":19}],73:[function(e,t,n){function r(e,t){this.currentState=t||null,this.states=e||{}}r.prototype.runTo=function(e,t,n,r){"function"==typeof e&&(r=n,n=t,t=e,e=null);var o=this,i=o.states[o.currentState];i.fn.call(n||o,r,(function(r){if(r){if(!i.fail)return t?t.call(n,r):null;o.currentState=i.fail}else{if(!i.accept)return t?t.call(n):null;o.currentState=i.accept}if(o.currentState===e)return t?t.call(n,r):null;o.runTo(e,t,n,r)}))},r.prototype.addState=function(e,t,n,r){return"function"==typeof t?(r=t,t=null,n=null):"function"==typeof n&&(r=n,n=null),this.currentState||(this.currentState=e),this.states[e]={accept:t,fail:n,fn:r},this},t.exports=r},{}],74:[function(e,t,n){(function(n,r){(function(){var i,a={environment:"nodejs",engine:function(){if(a.isBrowser()&&"undefined"!=typeof navigator)return navigator.userAgent;var e=n.platform+"/"+n.version;return n.env.AWS_EXECUTION_ENV&&(e+=" exec-env/"+n.env.AWS_EXECUTION_ENV),e},userAgent:function(){var t=a.environment,n="aws-sdk-"+t+"/"+e("./core").VERSION;return"nodejs"===t&&(n+=" "+a.engine()),n},uriEscape:function(e){var t=encodeURIComponent(e);return t=(t=t.replace(/[^A-Za-z0-9_.~\-%]+/g,escape)).replace(/[*]/g,(function(e){return"%"+e.charCodeAt(0).toString(16).toUpperCase()}))},uriEscapePath:function(e){var t=[];return a.arrayEach(e.split("/"),(function(e){t.push(a.uriEscape(e))})),t.join("/")},urlParse:function(e){return a.url.parse(e)},urlFormat:function(e){return a.url.format(e)},queryStringParse:function(e){return a.querystring.parse(e)},queryParamsToString:function(e){var t=[],n=a.uriEscape,r=Object.keys(e).sort();return a.arrayEach(r,(function(r){var o=e[r],i=n(r),s=i+"=";if(Array.isArray(o)){var c=[];a.arrayEach(o,(function(e){c.push(n(e))})),s=i+"="+c.sort().join("&"+i+"=")}else null!=o&&(s=i+"="+n(o));t.push(s)})),t.join("&")},readFileSync:function(t){return a.isBrowser()?null:e("fs").readFileSync(t,"utf-8")},base64:{encode:function(e){if("number"==typeof e)throw a.error(new Error("Cannot base64 encode number "+e));return null==e?e:a.buffer.toBuffer(e).toString("base64")},decode:function(e){if("number"==typeof e)throw a.error(new Error("Cannot base64 decode number "+e));return null==e?e:a.buffer.toBuffer(e,"base64")}},buffer:{toBuffer:function(e,t){return"function"==typeof a.Buffer.from&&a.Buffer.from!==Uint8Array.from?a.Buffer.from(e,t):new a.Buffer(e,t)},alloc:function(e,t,n){if("number"!=typeof e)throw new Error("size passed to alloc must be a number.");if("function"==typeof a.Buffer.alloc)return a.Buffer.alloc(e,t,n);var r=new a.Buffer(e);return void 0!==t&&"function"==typeof r.fill&&r.fill(t,void 0,void 0,n),r},toStream:function(e){a.Buffer.isBuffer(e)||(e=a.buffer.toBuffer(e));var t=new a.stream.Readable,n=0;return t._read=function(r){if(n>=e.length)return t.push(null);var o=n+r;o>e.length&&(o=e.length),t.push(e.slice(n,o)),n=o},t},concat:function(e){var t,n,r=0,o=0;for(n=0;n<e.length;n++)r+=e[n].length;for(t=a.buffer.alloc(r),n=0;n<e.length;n++)e[n].copy(t,o),o+=e[n].length;return t}},string:{byteLength:function(t){if(null==t)return 0;if("string"==typeof t&&(t=a.buffer.toBuffer(t)),"number"==typeof t.byteLength)return t.byteLength;if("number"==typeof t.length)return t.length;if("number"==typeof t.size)return t.size;if("string"==typeof t.path)return e("fs").lstatSync(t.path).size;throw a.error(new Error("Cannot determine length of "+t),{object:t})},upperFirst:function(e){return e[0].toUpperCase()+e.substr(1)},lowerFirst:function(e){return e[0].toLowerCase()+e.substr(1)}},ini:{parse:function(e){var t,n={};return a.arrayEach(e.split(/\r?\n/),(function(e){if("["===(e=e.split(/(^|\s)[;#]/)[0].trim())[0]&&"]"===e[e.length-1]){if("__proto__"===(t=e.substring(1,e.length-1))||"__proto__"===t.split(/\s/)[1])throw a.error(new Error("Cannot load profile name '"+t+"' from shared ini file."))}else if(t){var r=e.indexOf("="),o=e.length-1;if(-1!==r&&0!==r&&r!==o){var i=e.substring(0,r).trim(),s=e.substring(r+1).trim();n[t]=n[t]||{},n[t][i]=s}}})),n}},fn:{noop:function(){},callback:function(e){if(e)throw e},makeAsync:function(e,t){return t&&t<=e.length?e:function(){var t=Array.prototype.slice.call(arguments,0);t.pop()(e.apply(null,t))}}},date:{getDate:function(){return i||(i=e("./core")),i.config.systemClockOffset?new Date((new Date).getTime()+i.config.systemClockOffset):new Date},iso8601:function(e){return void 0===e&&(e=a.date.getDate()),e.toISOString().replace(/\.\d{3}Z$/,"Z")},rfc822:function(e){return void 0===e&&(e=a.date.getDate()),e.toUTCString()},unixTimestamp:function(e){return void 0===e&&(e=a.date.getDate()),e.getTime()/1e3},from:function(e){return"number"==typeof e?new Date(1e3*e):new Date(e)},format:function(e,t){return t||(t="iso8601"),a.date[t](a.date.from(e))},parseTimestamp:function(e){if("number"==typeof e)return new Date(1e3*e);if(e.match(/^\d+$/))return new Date(1e3*e);if(e.match(/^\d{4}/))return new Date(e);if(e.match(/^\w{3},/))return new Date(e);throw a.error(new Error("unhandled timestamp format: "+e),{code:"TimestampParserError"})}},crypto:{crc32Table:[0,1996959894,3993919788,2567524794,124634137,1886057615,3915621685,2657392035,249268274,2044508324,3772115230,2547177864,162941995,2125561021,3887607047,2428444049,498536548,1789927666,4089016648,2227061214,450548861,1843258603,4107580753,2211677639,325883990,1684777152,4251122042,2321926636,335633487,1661365465,4195302755,2366115317,997073096,1281953886,3579855332,2724688242,1006888145,1258607687,3524101629,2768942443,901097722,1119000684,3686517206,2898065728,853044451,1172266101,3705015759,2882616665,651767980,1373503546,3369554304,3218104598,565507253,1454621731,3485111705,3099436303,671266974,1594198024,3322730930,2970347812,795835527,1483230225,3244367275,3060149565,1994146192,31158534,2563907772,4023717930,1907459465,112637215,2680153253,3904427059,2013776290,251722036,2517215374,3775830040,2137656763,141376813,2439277719,3865271297,1802195444,476864866,2238001368,4066508878,1812370925,453092731,2181625025,4111451223,1706088902,314042704,2344532202,4240017532,1658658271,366619977,2362670323,4224994405,1303535960,984961486,2747007092,3569037538,1256170817,1037604311,2765210733,3554079995,1131014506,879679996,2909243462,3663771856,1141124467,855842277,2852801631,3708648649,1342533948,654459306,3188396048,3373015174,1466479909,544179635,3110523913,3462522015,1591671054,702138776,2966460450,3352799412,1504918807,783551873,3082640443,3233442989,3988292384,2596254646,62317068,1957810842,3939845945,2647816111,81470997,1943803523,3814918930,2489596804,225274430,2053790376,3826175755,2466906013,167816743,2097651377,4027552580,2265490386,503444072,1762050814,4150417245,2154129355,426522225,1852507879,4275313526,2312317920,282753626,1742555852,4189708143,2394877945,397917763,1622183637,3604390888,2714866558,953729732,1340076626,3518719985,2797360999,1068828381,1219638859,3624741850,2936675148,906185462,1090812512,3747672003,2825379669,829329135,1181335161,3412177804,3160834842,628085408,1382605366,3423369109,3138078467,570562233,1426400815,3317316542,2998733608,733239954,1555261956,3268935591,3050360625,752459403,1541320221,2607071920,3965973030,1969922972,40735498,2617837225,3943577151,1913087877,83908371,2512341634,3803740692,2075208622,213261112,2463272603,3855990285,2094854071,198958881,2262029012,4057260610,1759359992,534414190,2176718541,4139329115,1873836001,414664567,2282248934,4279200368,1711684554,285281116,2405801727,4167216745,1634467795,376229701,2685067896,3608007406,1308918612,956543938,2808555105,3495958263,1231636301,1047427035,2932959818,3654703836,1088359270,936918e3,2847714899,3736837829,1202900863,817233897,3183342108,3401237130,1404277552,615818150,3134207493,3453421203,1423857449,601450431,3009837614,3294710456,1567103746,711928724,3020668471,3272380065,1510334235,755167117],crc32:function(e){var t=a.crypto.crc32Table,n=-1;"string"==typeof e&&(e=a.buffer.toBuffer(e));for(var r=0;r<e.length;r++)n=n>>>8^t[255&(n^e.readUInt8(r))];return~n>>>0},hmac:function(e,t,n,r){return n||(n="binary"),"buffer"===n&&(n=void 0),r||(r="sha256"),"string"==typeof t&&(t=a.buffer.toBuffer(t)),a.crypto.lib.createHmac(r,e).update(t).digest(n)},md5:function(e,t,n){return a.crypto.hash("md5",e,t,n)},sha256:function(e,t,n){return a.crypto.hash("sha256",e,t,n)},hash:function(e,t,n,r){var i=a.crypto.createHash(e);n||(n="binary"),"buffer"===n&&(n=void 0),"string"==typeof t&&(t=a.buffer.toBuffer(t));var s=a.arraySliceFn(t),c=a.Buffer.isBuffer(t);if(a.isBrowser()&&"undefined"!=typeof ArrayBuffer&&t&&t.buffer instanceof ArrayBuffer&&(c=!0),r&&"object"===o(t)&&"function"==typeof t.on&&!c)t.on("data",(function(e){i.update(e)})),t.on("error",(function(e){r(e)})),t.on("end",(function(){r(null,i.digest(n))}));else{if(!r||!s||c||"undefined"==typeof FileReader){a.isBrowser()&&"object"===o(t)&&!c&&(t=new a.Buffer(new Uint8Array(t)));var u=i.update(t).digest(n);return r&&r(null,u),u}var l=0,p=new FileReader;p.onerror=function(){r(new Error("Failed to read data."))},p.onload=function(){var e=new a.Buffer(new Uint8Array(p.result));i.update(e),l+=e.length,p._continueReading()},p._continueReading=function(){if(l>=t.size)r(null,i.digest(n));else{var e=l+524288;e>t.size&&(e=t.size),p.readAsArrayBuffer(s.call(t,l,e))}},p._continueReading()}},toHex:function(e){for(var t=[],n=0;n<e.length;n++)t.push(("0"+e.charCodeAt(n).toString(16)).substr(-2,2));return t.join("")},createHash:function(e){return a.crypto.lib.createHash(e)}},abort:{},each:function(e,t){for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)&&t.call(this,n,e[n])===a.abort)break},arrayEach:function(e,t){for(var n in e)if(Object.prototype.hasOwnProperty.call(e,n)&&t.call(this,e[n],parseInt(n,10))===a.abort)break},update:function(e,t){return a.each(t,(function(t,n){e[t]=n})),e},merge:function(e,t){return a.update(a.copy(e),t)},copy:function(e){if(null==e)return e;var t={};for(var n in e)t[n]=e[n];return t},isEmpty:function(e){for(var t in e)if(Object.prototype.hasOwnProperty.call(e,t))return!1;return!0},arraySliceFn:function(e){var t=e.slice||e.webkitSlice||e.mozSlice;return"function"==typeof t?t:null},isType:function(e,t){return"function"==typeof t&&(t=a.typeName(t)),Object.prototype.toString.call(e)==="[object "+t+"]"},typeName:function(e){if(Object.prototype.hasOwnProperty.call(e,"name"))return e.name;var t=e.toString(),n=t.match(/^\s*function (.+)\(/);return n?n[1]:t},error:function(e,t){var n=null;for(var r in"string"==typeof e.message&&""!==e.message&&("string"==typeof t||t&&t.message)&&((n=a.copy(e)).message=e.message),e.message=e.message||null,"string"==typeof t?e.message=t:"object"===o(t)&&null!==t&&(a.update(e,t),t.message&&(e.message=t.message),(t.code||t.name)&&(e.code=t.code||t.name),t.stack&&(e.stack=t.stack)),"function"==typeof Object.defineProperty&&(Object.defineProperty(e,"name",{writable:!0,enumerable:!1}),Object.defineProperty(e,"message",{enumerable:!0})),e.name=String(t&&t.name||e.name||e.code||"Error"),e.time=new Date,n&&(e.originalError=n),t||{})if("["===r[0]&&"]"===r[r.length-1]){if("code"===(r=r.slice(1,-1))||"message"===r)continue;e["["+r+"]"]="See error."+r+" for details.",Object.defineProperty(e,r,{value:e[r]||t&&t[r]||n&&n[r],enumerable:!1,writable:!0})}return e},inherit:function(e,t){var n=null;if(void 0===t)t=e,e=Object,n={};else{var r=function(){};r.prototype=e.prototype,n=new r}return t.constructor===Object&&(t.constructor=function(){if(e!==Object)return e.apply(this,arguments)}),t.constructor.prototype=n,a.update(t.constructor.prototype,t),t.constructor.__super__=e,t.constructor},mixin:function(){for(var e=arguments[0],t=1;t<arguments.length;t++)for(var n in arguments[t].prototype){var r=arguments[t].prototype[n];"constructor"!==n&&(e.prototype[n]=r)}return e},hideProperties:function(e,t){"function"==typeof Object.defineProperty&&a.arrayEach(t,(function(t){Object.defineProperty(e,t,{enumerable:!1,writable:!0,configurable:!0})}))},property:function(e,t,n,r,o){var i={configurable:!0,enumerable:void 0===r||r};"function"!=typeof n||o?(i.value=n,i.writable=!0):i.get=n,Object.defineProperty(e,t,i)},memoizedProperty:function(e,t,n,r){var o=null;a.property(e,t,(function(){return null===o&&(o=n()),o}),r)},hoistPayloadMember:function(e){var t=e.request,n=t.operation,r=t.service.api.operations[n],o=r.output;if(o.payload&&!r.hasEventOutput){var i=o.members[o.payload],s=e.data[o.payload];"structure"===i.type&&a.each(s,(function(t,n){a.property(e.data,t,n,!1)}))}},computeSha256:function(t,n){if(a.isNode()){var r=a.stream.Stream,o=e("fs");if("function"==typeof r&&t instanceof r){if("string"!=typeof t.path)return n(new Error("Non-file stream objects are not supported with SigV4"));var i={};"number"==typeof t.start&&(i.start=t.start),"number"==typeof t.end&&(i.end=t.end),t=o.createReadStream(t.path,i)}}a.crypto.sha256(t,"hex",(function(e,t){e?n(e):n(null,t)}))},isClockSkewed:function(e){if(e)return a.property(i.config,"isClockSkewed",Math.abs((new Date).getTime()-e)>=3e5,!1),i.config.isClockSkewed},applyClockOffset:function(e){e&&(i.config.systemClockOffset=e-(new Date).getTime())},extractRequestId:function(e){var t=e.httpResponse.headers["x-amz-request-id"]||e.httpResponse.headers["x-amzn-requestid"];!t&&e.data&&e.data.ResponseMetadata&&(t=e.data.ResponseMetadata.RequestId),t&&(e.requestId=t),e.error&&(e.error.requestId=t)},addPromises:function(e,t){var n=!1;void 0===t&&i&&i.config&&(t=i.config.getPromisesDependency()),void 0===t&&"undefined"!=typeof Promise&&(t=Promise),"function"!=typeof t&&(n=!0),Array.isArray(e)||(e=[e]);for(var r=0;r<e.length;r++){var o=e[r];n?o.deletePromisesFromClass&&o.deletePromisesFromClass():o.addPromisesToClass&&o.addPromisesToClass(t)}},promisifyMethod:function(e,t){return function(){var n=this,r=Array.prototype.slice.call(arguments);return new t((function(t,o){r.push((function(e,n){e?o(e):t(n)})),n[e].apply(n,r)}))}},isDualstackAvailable:function(t){if(!t)return!1;var n=e("../apis/metadata.json");return"string"!=typeof t&&(t=t.serviceIdentifier),!("string"!=typeof t||!n.hasOwnProperty(t)||!n[t].dualstackAvailable)},calculateRetryDelay:function(e,t,n){t||(t={});var r=t.customBackoff||null;if("function"==typeof r)return r(e,n);var o="number"==typeof t.base?t.base:100;return Math.random()*(Math.pow(2,e)*o)},handleRequestWithRetries:function(e,t,n){t||(t={});var r=i.HttpClient.getInstance(),o=t.httpOptions||{},s=0,c=function(e){var r=t.maxRetries||0;if(e&&"TimeoutError"===e.code&&(e.retryable=!0),e&&e.retryable&&s<r){var o=a.calculateRetryDelay(s,t.retryDelayOptions,e);if(o>=0)return s++,void setTimeout(u,o+(e.retryAfter||0))}n(e)},u=function(){var t="";r.handleRequest(e,o,(function(e){e.on("data",(function(e){t+=e.toString()})),e.on("end",(function(){var r=e.statusCode;if(r<300)n(null,t);else{var o=1e3*parseInt(e.headers["retry-after"],10)||0,i=a.error(new Error,{statusCode:r,retryable:r>=500||429===r});o&&i.retryable&&(i.retryAfter=o),c(i)}}))}),c)};i.util.defer(u)},uuid:{v4:function(){return e("uuid").v4()}},convertPayloadToString:function(e){var t=e.request,n=t.operation,r=t.service.api.operations[n].output||{};r.payload&&e.data[r.payload]&&(e.data[r.payload]=e.data[r.payload].toString())},defer:function(e){"object"===o(n)&&"function"==typeof n.nextTick?n.nextTick(e):"function"==typeof r?r(e):setTimeout(e,0)},getRequestPayloadShape:function(e){var t=e.service.api.operations;if(t){var n=(t||{})[e.operation];if(n&&n.input&&n.input.payload)return n.input.members[n.input.payload]}},getProfilesFromSharedConfig:function(e,t){var r={},o={};n.env[a.configOptInEnv]&&(o=e.loadFrom({isConfig:!0,filename:n.env[a.sharedConfigFileEnv]}));var i={};try{i=e.loadFrom({filename:t||n.env[a.configOptInEnv]&&n.env[a.sharedCredentialsFileEnv]})}catch(e){if(!n.env[a.configOptInEnv])throw e}for(var s=0,c=Object.keys(o);s<c.length;s++)r[c[s]]=u(r[c[s]]||{},o[c[s]]);for(s=0,c=Object.keys(i);s<c.length;s++)r[c[s]]=u(r[c[s]]||{},i[c[s]]);return r;function u(e,t){for(var n=0,r=Object.keys(t);n<r.length;n++)e[r[n]]=t[r[n]];return e}},ARN:{validate:function(e){return e&&0===e.indexOf("arn:")&&e.split(":").length>=6},parse:function(e){var t=e.split(":");return{partition:t[1],service:t[2],region:t[3],accountId:t[4],resource:t.slice(5).join(":")}},build:function(e){if(void 0===e.service||void 0===e.region||void 0===e.accountId||void 0===e.resource)throw a.error(new Error("Input ARN object is invalid"));return"arn:"+(e.partition||"aws")+":"+e.service+":"+e.region+":"+e.accountId+":"+e.resource}},defaultProfile:"default",configOptInEnv:"AWS_SDK_LOAD_CONFIG",sharedCredentialsFileEnv:"AWS_SHARED_CREDENTIALS_FILE",sharedConfigFileEnv:"AWS_CONFIG_FILE",imdsDisabledEnv:"AWS_EC2_METADATA_DISABLED"};t.exports=a}).call(this)}).call(this,e("_process"),e("timers").setImmediate)},{"../apis/metadata.json":4,"./core":19,_process:91,fs:82,timers:99,uuid:102}],75:[function(e,t,n){var r=e("../util"),o=e("../model/shape");function i(){}function a(e,t){for(var n=e.getElementsByTagName(t),r=0,o=n.length;r<o;r++)if(n[r].parentNode===e)return n[r]}function s(e,t){switch(t||(t={}),t.type){case"structure":return c(e,t);case"map":return function(e,t){for(var n={},r=t.key.name||"key",o=t.value.name||"value",i=t.flattened?t.name:"entry",c=e.firstElementChild;c;){if(c.nodeName===i){var u=a(c,r).textContent,l=a(c,o);n[u]=s(l,t.value)}c=c.nextElementSibling}return n}(e,t);case"list":return function(e,t){for(var n=[],r=t.flattened?t.name:t.member.name||"member",o=e.firstElementChild;o;)o.nodeName===r&&n.push(s(o,t.member)),o=o.nextElementSibling;return n}(e,t);case void 0:case null:return function(e){if(null==e)return"";if(!e.firstElementChild)return null===e.parentNode.parentNode?{}:0===e.childNodes.length?"":e.textContent;for(var t={type:"structure",members:{}},n=e.firstElementChild;n;){var r=n.nodeName;Object.prototype.hasOwnProperty.call(t.members,r)?t.members[r].type="list":t.members[r]={name:r},n=n.nextElementSibling}return c(e,t)}(e);default:return function(e,t){if(e.getAttribute){var n=e.getAttribute("encoding");"base64"===n&&(t=new o.create({type:n}))}var r=e.textContent;return""===r&&(r=null),"function"==typeof t.toType?t.toType(r):r}(e,t)}}function c(e,t){var n={};return null===e||r.each(t.members,(function(r,o){if(o.isXmlAttribute){if(Object.prototype.hasOwnProperty.call(e.attributes,o.name)){var i=e.attributes[o.name].value;n[r]=s({textContent:i},o)}}else{var c=o.flattened?e:a(e,o.name);c?n[r]=s(c,o):o.flattened||"list"!==o.type||t.api.xmlNoDefaultLists||(n[r]=o.defaultValue)}})),n}i.prototype.parse=function(e,t){if(""===e.replace(/^\s+/,""))return{};var n,o;try{if(window.DOMParser){try{n=(new DOMParser).parseFromString(e,"text/xml")}catch(e){throw r.error(new Error("Parse error in document"),{originalError:e,code:"XMLParserError",retryable:!0})}if(null===n.documentElement)throw r.error(new Error("Cannot parse empty document."),{code:"XMLParserError",retryable:!0});var i=n.getElementsByTagName("parsererror")[0];if(i&&(i.parentNode===n||"body"===i.parentNode.nodeName||i.parentNode.parentNode===n||"body"===i.parentNode.parentNode.nodeName)){var c=i.getElementsByTagName("div")[0]||i;throw r.error(new Error(c.textContent||"Parser error in document"),{code:"XMLParserError",retryable:!0})}}else{if(!window.ActiveXObject)throw new Error("Cannot load XML parser");if((n=new window.ActiveXObject("Microsoft.XMLDOM")).async=!1,!n.loadXML(e))throw r.error(new Error("Parse error in document"),{code:"XMLParserError",retryable:!0})}}catch(e){o=e}if(n&&n.documentElement&&!o){var u=s(n.documentElement,t),l=a(n.documentElement,"ResponseMetadata");return l&&(u.ResponseMetadata=s(l,{})),u}if(o)throw r.error(o||new Error,{code:"XMLParserError",retryable:!0});return{}},t.exports=i},{"../model/shape":45,"../util":74}],76:[function(e,t,n){var r=e("../util"),o=e("./xml-node").XmlNode,i=e("./xml-text").XmlText;function a(){}function s(e,t,n){switch(n.type){case"structure":return function(e,t,n){r.arrayEach(n.memberNames,(function(r){var i=n.members[r];if("body"===i.location){var a=t[r],u=i.name;if(null!=a)if(i.isXmlAttribute)e.addAttribute(u,a);else if(i.flattened)s(e,a,i);else{var l=new o(u);e.addChildNode(l),c(l,i),s(l,a,i)}}}))}(e,t,n);case"map":return function(e,t,n){var i=n.key.name||"key",a=n.value.name||"value";r.each(t,(function(t,r){var c=new o(n.flattened?n.name:"entry");e.addChildNode(c);var u=new o(i),l=new o(a);c.addChildNode(u),c.addChildNode(l),s(u,t,n.key),s(l,r,n.value)}))}(e,t,n);case"list":return function(e,t,n){n.flattened?r.arrayEach(t,(function(t){var r=n.member.name||n.name,i=new o(r);e.addChildNode(i),s(i,t,n.member)})):r.arrayEach(t,(function(t){var r=n.member.name||"member",i=new o(r);e.addChildNode(i),s(i,t,n.member)}))}(e,t,n);default:return function(e,t,n){e.addChildNode(new i(n.toWireFormat(t)))}(e,t,n)}}function c(e,t,n){var r,o="xmlns";t.xmlNamespaceUri?(r=t.xmlNamespaceUri,t.xmlNamespacePrefix&&(o+=":"+t.xmlNamespacePrefix)):n&&t.api.xmlNamespaceUri&&(r=t.api.xmlNamespaceUri),r&&e.addAttribute(o,r)}a.prototype.toXML=function(e,t,n,r){var i=new o(n);return c(i,t,!0),s(i,e,t),i.children.length>0||r?i.toString():""},t.exports=a},{"../util":74,"./xml-node":79,"./xml-text":80}],77:[function(e,t,n){t.exports={escapeAttribute:function(e){return e.replace(/&/g,"&amp;").replace(/'/g,"&apos;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;")}}},{}],78:[function(e,t,n){t.exports={escapeElement:function(e){return e.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/\r/g,"&#x0D;").replace(/\n/g,"&#x0A;").replace(/\u0085/g,"&#x85;").replace(/\u2028/,"&#x2028;")}}},{}],79:[function(e,t,n){var r=e("./escape-attribute").escapeAttribute;function o(e,t){void 0===t&&(t=[]),this.name=e,this.children=t,this.attributes={}}o.prototype.addAttribute=function(e,t){return this.attributes[e]=t,this},o.prototype.addChildNode=function(e){return this.children.push(e),this},o.prototype.removeAttribute=function(e){return delete this.attributes[e],this},o.prototype.toString=function(){for(var e=Boolean(this.children.length),t="<"+this.name,n=this.attributes,o=0,i=Object.keys(n);o<i.length;o++){var a=i[o],s=n[a];null!=s&&(t+=" "+a+'="'+r(""+s)+'"')}return t+(e?">"+this.children.map((function(e){return e.toString()})).join("")+"</"+this.name+">":"/>")},t.exports={XmlNode:o}},{"./escape-attribute":77}],80:[function(e,t,n){var r=e("./escape-element").escapeElement;function o(e){this.value=e}o.prototype.toString=function(){return r(""+this.value)},t.exports={XmlText:o}},{"./escape-element":78}],81:[function(e,t,n){"use strict";n.byteLength=function(e){var t=c(e),n=t[0],r=t[1];return 3*(n+r)/4-r},n.toByteArray=function(e){var t,n,r=c(e),a=r[0],s=r[1],u=new i(function(e,t,n){return 3*(t+n)/4-n}(0,a,s)),l=0,p=s>0?a-4:a;for(n=0;n<p;n+=4)t=o[e.charCodeAt(n)]<<18|o[e.charCodeAt(n+1)]<<12|o[e.charCodeAt(n+2)]<<6|o[e.charCodeAt(n+3)],u[l++]=t>>16&255,u[l++]=t>>8&255,u[l++]=255&t;return 2===s&&(t=o[e.charCodeAt(n)]<<2|o[e.charCodeAt(n+1)]>>4,u[l++]=255&t),1===s&&(t=o[e.charCodeAt(n)]<<10|o[e.charCodeAt(n+1)]<<4|o[e.charCodeAt(n+2)]>>2,u[l++]=t>>8&255,u[l++]=255&t),u},n.fromByteArray=function(e){for(var t,n=e.length,o=n%3,i=[],a=16383,s=0,c=n-o;s<c;s+=a)i.push(u(e,s,s+a>c?c:s+a));return 1===o?(t=e[n-1],i.push(r[t>>2]+r[t<<4&63]+"==")):2===o&&(t=(e[n-2]<<8)+e[n-1],i.push(r[t>>10]+r[t>>4&63]+r[t<<2&63]+"=")),i.join("")};for(var r=[],o=[],i="undefined"!=typeof Uint8Array?Uint8Array:Array,a="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=0;s<64;++s)r[s]=a[s],o[a.charCodeAt(s)]=s;function c(e){var t=e.length;if(t%4>0)throw new Error("Invalid string. Length must be a multiple of 4");var n=e.indexOf("=");return-1===n&&(n=t),[n,n===t?0:4-n%4]}function u(e,t,n){for(var o,i,a=[],s=t;s<n;s+=3)o=(e[s]<<16&16711680)+(e[s+1]<<8&65280)+(255&e[s+2]),a.push(r[(i=o)>>18&63]+r[i>>12&63]+r[i>>6&63]+r[63&i]);return a.join("")}o["-".charCodeAt(0)]=62,o["_".charCodeAt(0)]=63},{}],82:[function(e,t,n){},{}],83:[function(e,t,n){"function"==typeof Object.create?t.exports=function(e,t){e.super_=t,e.prototype=Object.create(t.prototype,{constructor:{value:e,enumerable:!1,writable:!0,configurable:!0}})}:t.exports=function(e,t){e.super_=t;var n=function(){};n.prototype=t.prototype,e.prototype=new n,e.prototype.constructor=e}},{}],84:[function(e,t,n){t.exports=function(e){return e&&"object"===o(e)&&"function"==typeof e.copy&&"function"==typeof e.fill&&"function"==typeof e.readUInt8}},{}],85:[function(e,t,r){(function(t,n){(function(){var i=/%[sdj%]/g;r.format=function(e){if(!y(e)){for(var t=[],n=0;n<arguments.length;n++)t.push(c(arguments[n]));return t.join(" ")}n=1;for(var r=arguments,o=r.length,a=String(e).replace(i,(function(e){if("%%"===e)return"%";if(n>=o)return e;switch(e){case"%s":return String(r[n++]);case"%d":return Number(r[n++]);case"%j":try{return JSON.stringify(r[n++])}catch(e){return"[Circular]"}default:return e}})),s=r[n];n<o;s=r[++n])m(s)||!S(s)?a+=" "+s:a+=" "+c(s);return a},r.deprecate=function(e,o){if(b(n.process))return function(){return r.deprecate(e,o).apply(this,arguments)};if(!0===t.noDeprecation)return e;var i=!1;return function(){if(!i){if(t.throwDeprecation)throw new Error(o);t.traceDeprecation?console.trace(o):console.error(o),i=!0}return e.apply(this,arguments)}};var a,s={};function c(e,t){var n={seen:[],stylize:l};return arguments.length>=3&&(n.depth=arguments[2]),arguments.length>=4&&(n.colors=arguments[3]),g(t)?n.showHidden=t:t&&r._extend(n,t),b(n.showHidden)&&(n.showHidden=!1),b(n.depth)&&(n.depth=2),b(n.colors)&&(n.colors=!1),b(n.customInspect)&&(n.customInspect=!0),n.colors&&(n.stylize=u),p(n,e,n.depth)}function u(e,t){var n=c.styles[t];return n?"["+c.colors[n][0]+"m"+e+"["+c.colors[n][1]+"m":e}function l(e,t){return e}function p(e,t,n){if(e.customInspect&&t&&I(t.inspect)&&t.inspect!==r.inspect&&(!t.constructor||t.constructor.prototype!==t)){var o=t.inspect(n,e);return y(o)||(o=p(e,o,n)),o}var i=function(e,t){if(b(t))return e.stylize("undefined","undefined");if(y(t)){var n="'"+JSON.stringify(t).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return e.stylize(n,"string")}return v(t)?e.stylize(""+t,"number"):g(t)?e.stylize(""+t,"boolean"):m(t)?e.stylize("null","null"):void 0}(e,t);if(i)return i;var a=Object.keys(t),s=function(e){var t={};return e.forEach((function(e,n){t[e]=!0})),t}(a);if(e.showHidden&&(a=Object.getOwnPropertyNames(t)),T(t)&&(a.indexOf("message")>=0||a.indexOf("description")>=0))return d(t);if(0===a.length){if(I(t)){var c=t.name?": "+t.name:"";return e.stylize("[Function"+c+"]","special")}if(E(t))return e.stylize(RegExp.prototype.toString.call(t),"regexp");if(C(t))return e.stylize(Date.prototype.toString.call(t),"date");if(T(t))return d(t)}var u,l="",S=!1,w=["{","}"];return h(t)&&(S=!0,w=["[","]"]),I(t)&&(l=" [Function"+(t.name?": "+t.name:"")+"]"),E(t)&&(l=" "+RegExp.prototype.toString.call(t)),C(t)&&(l=" "+Date.prototype.toUTCString.call(t)),T(t)&&(l=" "+d(t)),0!==a.length||S&&0!=t.length?n<0?E(t)?e.stylize(RegExp.prototype.toString.call(t),"regexp"):e.stylize("[Object]","special"):(e.seen.push(t),u=S?function(e,t,n,r,o){for(var i=[],a=0,s=t.length;a<s;++a)R(t,String(a))?i.push(f(e,t,n,r,String(a),!0)):i.push("");return o.forEach((function(o){o.match(/^\d+$/)||i.push(f(e,t,n,r,o,!0))})),i}(e,t,n,s,a):a.map((function(r){return f(e,t,n,s,r,S)})),e.seen.pop(),function(e,t,n){var r=e.reduce((function(e,t){return t.indexOf("\n"),e+t.replace(/\u001b\[\d\d?m/g,"").length+1}),0);return r>60?n[0]+(""===t?"":t+"\n ")+" "+e.join(",\n  ")+" "+n[1]:n[0]+t+" "+e.join(", ")+" "+n[1]}(u,l,w)):w[0]+l+w[1]}function d(e){return"["+Error.prototype.toString.call(e)+"]"}function f(e,t,n,r,o,i){var a,s,c;if((c=Object.getOwnPropertyDescriptor(t,o)||{value:t[o]}).get?s=c.set?e.stylize("[Getter/Setter]","special"):e.stylize("[Getter]","special"):c.set&&(s=e.stylize("[Setter]","special")),R(r,o)||(a="["+o+"]"),s||(e.seen.indexOf(c.value)<0?(s=m(n)?p(e,c.value,null):p(e,c.value,n-1)).indexOf("\n")>-1&&(s=i?s.split("\n").map((function(e){return"  "+e})).join("\n").substr(2):"\n"+s.split("\n").map((function(e){return"   "+e})).join("\n")):s=e.stylize("[Circular]","special")),b(a)){if(i&&o.match(/^\d+$/))return s;(a=JSON.stringify(""+o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(a=a.substr(1,a.length-2),a=e.stylize(a,"name")):(a=a.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),a=e.stylize(a,"string"))}return a+": "+s}function h(e){return Array.isArray(e)}function g(e){return"boolean"==typeof e}function m(e){return null===e}function v(e){return"number"==typeof e}function y(e){return"string"==typeof e}function b(e){return void 0===e}function E(e){return S(e)&&"[object RegExp]"===w(e)}function S(e){return"object"===o(e)&&null!==e}function C(e){return S(e)&&"[object Date]"===w(e)}function T(e){return S(e)&&("[object Error]"===w(e)||e instanceof Error)}function I(e){return"function"==typeof e}function w(e){return Object.prototype.toString.call(e)}function A(e){return e<10?"0"+e.toString(10):e.toString(10)}r.debuglog=function(e){if(b(a)&&(a=t.env.NODE_DEBUG||""),e=e.toUpperCase(),!s[e])if(new RegExp("\\b"+e+"\\b","i").test(a)){var n=t.pid;s[e]=function(){var t=r.format.apply(r,arguments);console.error("%s %d: %s",e,n,t)}}else s[e]=function(){};return s[e]},r.inspect=c,c.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},c.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},r.isArray=h,r.isBoolean=g,r.isNull=m,r.isNullOrUndefined=function(e){return null==e},r.isNumber=v,r.isString=y,r.isSymbol=function(e){return"symbol"===o(e)},r.isUndefined=b,r.isRegExp=E,r.isObject=S,r.isDate=C,r.isError=T,r.isFunction=I,r.isPrimitive=function(e){return null===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||"symbol"===o(e)||void 0===e},r.isBuffer=e("./support/isBuffer");var _=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function R(e,t){return Object.prototype.hasOwnProperty.call(e,t)}r.log=function(){var e,t;console.log("%s - %s",(e=new Date,t=[A(e.getHours()),A(e.getMinutes()),A(e.getSeconds())].join(":"),[e.getDate(),_[e.getMonth()],t].join(" ")),r.format.apply(r,arguments))},r.inherits=e("inherits"),r._extend=function(e,t){if(!t||!S(t))return e;for(var n=Object.keys(t),r=n.length;r--;)e[n[r]]=t[n[r]];return e}}).call(this)}).call(this,e("_process"),void 0!==n.g?n.g:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":84,_process:91,inherits:83}],86:[function(e,t,r){(function(t,n){(function(){"use strict";var n=e("base64-js"),o=e("ieee754"),i=e("isarray");function a(){return c.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function s(e,t){if(a()<t)throw new RangeError("Invalid typed array length");return c.TYPED_ARRAY_SUPPORT?(e=new Uint8Array(t)).__proto__=c.prototype:(null===e&&(e=new c(t)),e.length=t),e}function c(e,t,n){if(!(c.TYPED_ARRAY_SUPPORT||this instanceof c))return new c(e,t,n);if("number"==typeof e){if("string"==typeof t)throw new Error("If encoding is specified then the first argument must be a string");return p(this,e)}return u(this,e,t,n)}function u(e,t,n,r){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return"undefined"!=typeof ArrayBuffer&&t instanceof ArrayBuffer?function(e,t,n,r){if(t.byteLength,n<0||t.byteLength<n)throw new RangeError("'offset' is out of bounds");if(t.byteLength<n+(r||0))throw new RangeError("'length' is out of bounds");return t=void 0===n&&void 0===r?new Uint8Array(t):void 0===r?new Uint8Array(t,n):new Uint8Array(t,n,r),c.TYPED_ARRAY_SUPPORT?(e=t).__proto__=c.prototype:e=d(e,t),e}(e,t,n,r):"string"==typeof t?function(e,t,n){if("string"==typeof n&&""!==n||(n="utf8"),!c.isEncoding(n))throw new TypeError('"encoding" must be a valid string encoding');var r=0|h(t,n),o=(e=s(e,r)).write(t,n);return o!==r&&(e=e.slice(0,o)),e}(e,t,n):function(e,t){if(c.isBuffer(t)){var n=0|f(t.length);return 0===(e=s(e,n)).length||t.copy(e,0,0,n),e}if(t){if("undefined"!=typeof ArrayBuffer&&t.buffer instanceof ArrayBuffer||"length"in t)return"number"!=typeof t.length||(r=t.length)!=r?s(e,0):d(e,t);if("Buffer"===t.type&&i(t.data))return d(e,t.data)}var r;throw new TypeError("First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.")}(e,t)}function l(e){if("number"!=typeof e)throw new TypeError('"size" argument must be a number');if(e<0)throw new RangeError('"size" argument must not be negative')}function p(e,t){if(l(t),e=s(e,t<0?0:0|f(t)),!c.TYPED_ARRAY_SUPPORT)for(var n=0;n<t;++n)e[n]=0;return e}function d(e,t){var n=t.length<0?0:0|f(t.length);e=s(e,n);for(var r=0;r<n;r+=1)e[r]=255&t[r];return e}function f(e){if(e>=a())throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a().toString(16)+" bytes");return 0|e}function h(e,t){if(c.isBuffer(e))return e.length;if("undefined"!=typeof ArrayBuffer&&"function"==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;"string"!=typeof e&&(e=""+e);var n=e.length;if(0===n)return 0;for(var r=!1;;)switch(t){case"ascii":case"latin1":case"binary":return n;case"utf8":case"utf-8":case void 0:return q(e).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*n;case"hex":return n>>>1;case"base64":return B(e).length;default:if(r)return q(e).length;t=(""+t).toLowerCase(),r=!0}}function g(e,t,n){var r=!1;if((void 0===t||t<0)&&(t=0),t>this.length)return"";if((void 0===n||n>this.length)&&(n=this.length),n<=0)return"";if((n>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return L(this,t,n);case"utf8":case"utf-8":return A(this,t,n);case"ascii":return R(this,t,n);case"latin1":case"binary":return O(this,t,n);case"base64":return w(this,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return k(this,t,n);default:if(r)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),r=!0}}function m(e,t,n){var r=e[t];e[t]=e[n],e[n]=r}function v(e,t,n,r,o){if(0===e.length)return-1;if("string"==typeof n?(r=n,n=0):n>2147483647?n=2147483647:n<-2147483648&&(n=-2147483648),n=+n,isNaN(n)&&(n=o?0:e.length-1),n<0&&(n=e.length+n),n>=e.length){if(o)return-1;n=e.length-1}else if(n<0){if(!o)return-1;n=0}if("string"==typeof t&&(t=c.from(t,r)),c.isBuffer(t))return 0===t.length?-1:y(e,t,n,r,o);if("number"==typeof t)return t&=255,c.TYPED_ARRAY_SUPPORT&&"function"==typeof Uint8Array.prototype.indexOf?o?Uint8Array.prototype.indexOf.call(e,t,n):Uint8Array.prototype.lastIndexOf.call(e,t,n):y(e,[t],n,r,o);throw new TypeError("val must be string, number or Buffer")}function y(e,t,n,r,o){var i,a=1,s=e.length,c=t.length;if(void 0!==r&&("ucs2"===(r=String(r).toLowerCase())||"ucs-2"===r||"utf16le"===r||"utf-16le"===r)){if(e.length<2||t.length<2)return-1;a=2,s/=2,c/=2,n/=2}function u(e,t){return 1===a?e[t]:e.readUInt16BE(t*a)}if(o){var l=-1;for(i=n;i<s;i++)if(u(e,i)===u(t,-1===l?0:i-l)){if(-1===l&&(l=i),i-l+1===c)return l*a}else-1!==l&&(i-=i-l),l=-1}else for(n+c>s&&(n=s-c),i=n;i>=0;i--){for(var p=!0,d=0;d<c;d++)if(u(e,i+d)!==u(t,d)){p=!1;break}if(p)return i}return-1}function b(e,t,n,r){n=Number(n)||0;var o=e.length-n;r?(r=Number(r))>o&&(r=o):r=o;var i=t.length;if(i%2!=0)throw new TypeError("Invalid hex string");r>i/2&&(r=i/2);for(var a=0;a<r;++a){var s=parseInt(t.substr(2*a,2),16);if(isNaN(s))return a;e[n+a]=s}return a}function E(e,t,n,r){return G(q(t,e.length-n),e,n,r)}function S(e,t,n,r){return G(function(e){for(var t=[],n=0;n<e.length;++n)t.push(255&e.charCodeAt(n));return t}(t),e,n,r)}function C(e,t,n,r){return S(e,t,n,r)}function T(e,t,n,r){return G(B(t),e,n,r)}function I(e,t,n,r){return G(function(e,t){for(var n,r,o,i=[],a=0;a<e.length&&!((t-=2)<0);++a)r=(n=e.charCodeAt(a))>>8,o=n%256,i.push(o),i.push(r);return i}(t,e.length-n),e,n,r)}function w(e,t,r){return 0===t&&r===e.length?n.fromByteArray(e):n.fromByteArray(e.slice(t,r))}function A(e,t,n){n=Math.min(e.length,n);for(var r=[],o=t;o<n;){var i,a,s,c,u=e[o],l=null,p=u>239?4:u>223?3:u>191?2:1;if(o+p<=n)switch(p){case 1:u<128&&(l=u);break;case 2:128==(192&(i=e[o+1]))&&(c=(31&u)<<6|63&i)>127&&(l=c);break;case 3:i=e[o+1],a=e[o+2],128==(192&i)&&128==(192&a)&&(c=(15&u)<<12|(63&i)<<6|63&a)>2047&&(c<55296||c>57343)&&(l=c);break;case 4:i=e[o+1],a=e[o+2],s=e[o+3],128==(192&i)&&128==(192&a)&&128==(192&s)&&(c=(15&u)<<18|(63&i)<<12|(63&a)<<6|63&s)>65535&&c<1114112&&(l=c)}null===l?(l=65533,p=1):l>65535&&(l-=65536,r.push(l>>>10&1023|55296),l=56320|1023&l),r.push(l),o+=p}return function(e){var t=e.length;if(t<=_)return String.fromCharCode.apply(String,e);for(var n="",r=0;r<t;)n+=String.fromCharCode.apply(String,e.slice(r,r+=_));return n}(r)}r.Buffer=c,r.SlowBuffer=function(e){return+e!=e&&(e=0),c.alloc(+e)},r.INSPECT_MAX_BYTES=50,c.TYPED_ARRAY_SUPPORT=void 0!==t.TYPED_ARRAY_SUPPORT?t.TYPED_ARRAY_SUPPORT:function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&"function"==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(e){return!1}}(),r.kMaxLength=a(),c.poolSize=8192,c._augment=function(e){return e.__proto__=c.prototype,e},c.from=function(e,t,n){return u(null,e,t,n)},c.TYPED_ARRAY_SUPPORT&&(c.prototype.__proto__=Uint8Array.prototype,c.__proto__=Uint8Array,"undefined"!=typeof Symbol&&Symbol.species&&c[Symbol.species]===c&&Object.defineProperty(c,Symbol.species,{value:null,configurable:!0})),c.alloc=function(e,t,n){return function(e,t,n,r){return l(t),t<=0?s(e,t):void 0!==n?"string"==typeof r?s(e,t).fill(n,r):s(e,t).fill(n):s(e,t)}(null,e,t,n)},c.allocUnsafe=function(e){return p(null,e)},c.allocUnsafeSlow=function(e){return p(null,e)},c.isBuffer=function(e){return!(null==e||!e._isBuffer)},c.compare=function(e,t){if(!c.isBuffer(e)||!c.isBuffer(t))throw new TypeError("Arguments must be Buffers");if(e===t)return 0;for(var n=e.length,r=t.length,o=0,i=Math.min(n,r);o<i;++o)if(e[o]!==t[o]){n=e[o],r=t[o];break}return n<r?-1:r<n?1:0},c.isEncoding=function(e){switch(String(e).toLowerCase()){case"hex":case"utf8":case"utf-8":case"ascii":case"latin1":case"binary":case"base64":case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return!0;default:return!1}},c.concat=function(e,t){if(!i(e))throw new TypeError('"list" argument must be an Array of Buffers');if(0===e.length)return c.alloc(0);var n;if(void 0===t)for(t=0,n=0;n<e.length;++n)t+=e[n].length;var r=c.allocUnsafe(t),o=0;for(n=0;n<e.length;++n){var a=e[n];if(!c.isBuffer(a))throw new TypeError('"list" argument must be an Array of Buffers');a.copy(r,o),o+=a.length}return r},c.byteLength=h,c.prototype._isBuffer=!0,c.prototype.swap16=function(){var e=this.length;if(e%2!=0)throw new RangeError("Buffer size must be a multiple of 16-bits");for(var t=0;t<e;t+=2)m(this,t,t+1);return this},c.prototype.swap32=function(){var e=this.length;if(e%4!=0)throw new RangeError("Buffer size must be a multiple of 32-bits");for(var t=0;t<e;t+=4)m(this,t,t+3),m(this,t+1,t+2);return this},c.prototype.swap64=function(){var e=this.length;if(e%8!=0)throw new RangeError("Buffer size must be a multiple of 64-bits");for(var t=0;t<e;t+=8)m(this,t,t+7),m(this,t+1,t+6),m(this,t+2,t+5),m(this,t+3,t+4);return this},c.prototype.toString=function(){var e=0|this.length;return 0===e?"":0===arguments.length?A(this,0,e):g.apply(this,arguments)},c.prototype.equals=function(e){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===c.compare(this,e)},c.prototype.inspect=function(){var e="",t=r.INSPECT_MAX_BYTES;return this.length>0&&(e=this.toString("hex",0,t).match(/.{2}/g).join(" "),this.length>t&&(e+=" ... ")),"<Buffer "+e+">"},c.prototype.compare=function(e,t,n,r,o){if(!c.isBuffer(e))throw new TypeError("Argument must be a Buffer");if(void 0===t&&(t=0),void 0===n&&(n=e?e.length:0),void 0===r&&(r=0),void 0===o&&(o=this.length),t<0||n>e.length||r<0||o>this.length)throw new RangeError("out of range index");if(r>=o&&t>=n)return 0;if(r>=o)return-1;if(t>=n)return 1;if(this===e)return 0;for(var i=(o>>>=0)-(r>>>=0),a=(n>>>=0)-(t>>>=0),s=Math.min(i,a),u=this.slice(r,o),l=e.slice(t,n),p=0;p<s;++p)if(u[p]!==l[p]){i=u[p],a=l[p];break}return i<a?-1:a<i?1:0},c.prototype.includes=function(e,t,n){return-1!==this.indexOf(e,t,n)},c.prototype.indexOf=function(e,t,n){return v(this,e,t,n,!0)},c.prototype.lastIndexOf=function(e,t,n){return v(this,e,t,n,!1)},c.prototype.write=function(e,t,n,r){if(void 0===t)r="utf8",n=this.length,t=0;else if(void 0===n&&"string"==typeof t)r=t,n=this.length,t=0;else{if(!isFinite(t))throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");t|=0,isFinite(n)?(n|=0,void 0===r&&(r="utf8")):(r=n,n=void 0)}var o=this.length-t;if((void 0===n||n>o)&&(n=o),e.length>0&&(n<0||t<0)||t>this.length)throw new RangeError("Attempt to write outside buffer bounds");r||(r="utf8");for(var i=!1;;)switch(r){case"hex":return b(this,e,t,n);case"utf8":case"utf-8":return E(this,e,t,n);case"ascii":return S(this,e,t,n);case"latin1":case"binary":return C(this,e,t,n);case"base64":return T(this,e,t,n);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return I(this,e,t,n);default:if(i)throw new TypeError("Unknown encoding: "+r);r=(""+r).toLowerCase(),i=!0}},c.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var _=4096;function R(e,t,n){var r="";n=Math.min(e.length,n);for(var o=t;o<n;++o)r+=String.fromCharCode(127&e[o]);return r}function O(e,t,n){var r="";n=Math.min(e.length,n);for(var o=t;o<n;++o)r+=String.fromCharCode(e[o]);return r}function L(e,t,n){var r,o=e.length;(!t||t<0)&&(t=0),(!n||n<0||n>o)&&(n=o);for(var i="",a=t;a<n;++a)i+=(r=e[a])<16?"0"+r.toString(16):r.toString(16);return i}function k(e,t,n){for(var r=e.slice(t,n),o="",i=0;i<r.length;i+=2)o+=String.fromCharCode(r[i]+256*r[i+1]);return o}function N(e,t,n){if(e%1!=0||e<0)throw new RangeError("offset is not uint");if(e+t>n)throw new RangeError("Trying to access beyond buffer length")}function P(e,t,n,r,o,i){if(!c.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>o||t<i)throw new RangeError('"value" argument is out of bounds');if(n+r>e.length)throw new RangeError("Index out of range")}function D(e,t,n,r){t<0&&(t=65535+t+1);for(var o=0,i=Math.min(e.length-n,2);o<i;++o)e[n+o]=(t&255<<8*(r?o:1-o))>>>8*(r?o:1-o)}function x(e,t,n,r){t<0&&(t=4294967295+t+1);for(var o=0,i=Math.min(e.length-n,4);o<i;++o)e[n+o]=t>>>8*(r?o:3-o)&255}function M(e,t,n,r,o,i){if(n+r>e.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("Index out of range")}function U(e,t,n,r,i){return i||M(e,0,n,4),o.write(e,t,n,r,23,4),n+4}function F(e,t,n,r,i){return i||M(e,0,n,8),o.write(e,t,n,r,52,8),n+8}c.prototype.slice=function(e,t){var n,r=this.length;if((e=~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),(t=void 0===t?r:~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),t<e&&(t=e),c.TYPED_ARRAY_SUPPORT)(n=this.subarray(e,t)).__proto__=c.prototype;else{var o=t-e;n=new c(o,void 0);for(var i=0;i<o;++i)n[i]=this[i+e]}return n},c.prototype.readUIntLE=function(e,t,n){e|=0,t|=0,n||N(e,t,this.length);for(var r=this[e],o=1,i=0;++i<t&&(o*=256);)r+=this[e+i]*o;return r},c.prototype.readUIntBE=function(e,t,n){e|=0,t|=0,n||N(e,t,this.length);for(var r=this[e+--t],o=1;t>0&&(o*=256);)r+=this[e+--t]*o;return r},c.prototype.readUInt8=function(e,t){return t||N(e,1,this.length),this[e]},c.prototype.readUInt16LE=function(e,t){return t||N(e,2,this.length),this[e]|this[e+1]<<8},c.prototype.readUInt16BE=function(e,t){return t||N(e,2,this.length),this[e]<<8|this[e+1]},c.prototype.readUInt32LE=function(e,t){return t||N(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},c.prototype.readUInt32BE=function(e,t){return t||N(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},c.prototype.readIntLE=function(e,t,n){e|=0,t|=0,n||N(e,t,this.length);for(var r=this[e],o=1,i=0;++i<t&&(o*=256);)r+=this[e+i]*o;return r>=(o*=128)&&(r-=Math.pow(2,8*t)),r},c.prototype.readIntBE=function(e,t,n){e|=0,t|=0,n||N(e,t,this.length);for(var r=t,o=1,i=this[e+--r];r>0&&(o*=256);)i+=this[e+--r]*o;return i>=(o*=128)&&(i-=Math.pow(2,8*t)),i},c.prototype.readInt8=function(e,t){return t||N(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},c.prototype.readInt16LE=function(e,t){t||N(e,2,this.length);var n=this[e]|this[e+1]<<8;return 32768&n?4294901760|n:n},c.prototype.readInt16BE=function(e,t){t||N(e,2,this.length);var n=this[e+1]|this[e]<<8;return 32768&n?4294901760|n:n},c.prototype.readInt32LE=function(e,t){return t||N(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},c.prototype.readInt32BE=function(e,t){return t||N(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},c.prototype.readFloatLE=function(e,t){return t||N(e,4,this.length),o.read(this,e,!0,23,4)},c.prototype.readFloatBE=function(e,t){return t||N(e,4,this.length),o.read(this,e,!1,23,4)},c.prototype.readDoubleLE=function(e,t){return t||N(e,8,this.length),o.read(this,e,!0,52,8)},c.prototype.readDoubleBE=function(e,t){return t||N(e,8,this.length),o.read(this,e,!1,52,8)},c.prototype.writeUIntLE=function(e,t,n,r){e=+e,t|=0,n|=0,r||P(this,e,t,n,Math.pow(2,8*n)-1,0);var o=1,i=0;for(this[t]=255&e;++i<n&&(o*=256);)this[t+i]=e/o&255;return t+n},c.prototype.writeUIntBE=function(e,t,n,r){e=+e,t|=0,n|=0,r||P(this,e,t,n,Math.pow(2,8*n)-1,0);var o=n-1,i=1;for(this[t+o]=255&e;--o>=0&&(i*=256);)this[t+o]=e/i&255;return t+n},c.prototype.writeUInt8=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,1,255,0),c.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),this[t]=255&e,t+1},c.prototype.writeUInt16LE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,2,65535,0),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):D(this,e,t,!0),t+2},c.prototype.writeUInt16BE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,2,65535,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):D(this,e,t,!1),t+2},c.prototype.writeUInt32LE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):x(this,e,t,!0),t+4},c.prototype.writeUInt32BE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,4,4294967295,0),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):x(this,e,t,!1),t+4},c.prototype.writeIntLE=function(e,t,n,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*n-1);P(this,e,t,n,o-1,-o)}var i=0,a=1,s=0;for(this[t]=255&e;++i<n&&(a*=256);)e<0&&0===s&&0!==this[t+i-1]&&(s=1),this[t+i]=(e/a|0)-s&255;return t+n},c.prototype.writeIntBE=function(e,t,n,r){if(e=+e,t|=0,!r){var o=Math.pow(2,8*n-1);P(this,e,t,n,o-1,-o)}var i=n-1,a=1,s=0;for(this[t+i]=255&e;--i>=0&&(a*=256);)e<0&&0===s&&0!==this[t+i+1]&&(s=1),this[t+i]=(e/a|0)-s&255;return t+n},c.prototype.writeInt8=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,1,127,-128),c.TYPED_ARRAY_SUPPORT||(e=Math.floor(e)),e<0&&(e=255+e+1),this[t]=255&e,t+1},c.prototype.writeInt16LE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):D(this,e,t,!0),t+2},c.prototype.writeInt16BE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,2,32767,-32768),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):D(this,e,t,!1),t+2},c.prototype.writeInt32LE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,4,2147483647,-2147483648),c.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):x(this,e,t,!0),t+4},c.prototype.writeInt32BE=function(e,t,n){return e=+e,t|=0,n||P(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),c.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):x(this,e,t,!1),t+4},c.prototype.writeFloatLE=function(e,t,n){return U(this,e,t,!0,n)},c.prototype.writeFloatBE=function(e,t,n){return U(this,e,t,!1,n)},c.prototype.writeDoubleLE=function(e,t,n){return F(this,e,t,!0,n)},c.prototype.writeDoubleBE=function(e,t,n){return F(this,e,t,!1,n)},c.prototype.copy=function(e,t,n,r){if(n||(n=0),r||0===r||(r=this.length),t>=e.length&&(t=e.length),t||(t=0),r>0&&r<n&&(r=n),r===n)return 0;if(0===e.length||0===this.length)return 0;if(t<0)throw new RangeError("targetStart out of bounds");if(n<0||n>=this.length)throw new RangeError("sourceStart out of bounds");if(r<0)throw new RangeError("sourceEnd out of bounds");r>this.length&&(r=this.length),e.length-t<r-n&&(r=e.length-t+n);var o,i=r-n;if(this===e&&n<t&&t<r)for(o=i-1;o>=0;--o)e[o+t]=this[o+n];else if(i<1e3||!c.TYPED_ARRAY_SUPPORT)for(o=0;o<i;++o)e[o+t]=this[o+n];else Uint8Array.prototype.set.call(e,this.subarray(n,n+i),t);return i},c.prototype.fill=function(e,t,n,r){if("string"==typeof e){if("string"==typeof t?(r=t,t=0,n=this.length):"string"==typeof n&&(r=n,n=this.length),1===e.length){var o=e.charCodeAt(0);o<256&&(e=o)}if(void 0!==r&&"string"!=typeof r)throw new TypeError("encoding must be a string");if("string"==typeof r&&!c.isEncoding(r))throw new TypeError("Unknown encoding: "+r)}else"number"==typeof e&&(e&=255);if(t<0||this.length<t||this.length<n)throw new RangeError("Out of range index");if(n<=t)return this;var i;if(t>>>=0,n=void 0===n?this.length:n>>>0,e||(e=0),"number"==typeof e)for(i=t;i<n;++i)this[i]=e;else{var a=c.isBuffer(e)?e:q(new c(e,r).toString()),s=a.length;for(i=0;i<n-t;++i)this[i+t]=a[i%s]}return this};var j=/[^+\/0-9A-Za-z-_]/g;function q(e,t){var n;t=t||1/0;for(var r=e.length,o=null,i=[],a=0;a<r;++a){if((n=e.charCodeAt(a))>55295&&n<57344){if(!o){if(n>56319){(t-=3)>-1&&i.push(239,191,189);continue}if(a+1===r){(t-=3)>-1&&i.push(239,191,189);continue}o=n;continue}if(n<56320){(t-=3)>-1&&i.push(239,191,189),o=n;continue}n=65536+(o-55296<<10|n-56320)}else o&&(t-=3)>-1&&i.push(239,191,189);if(o=null,n<128){if((t-=1)<0)break;i.push(n)}else if(n<2048){if((t-=2)<0)break;i.push(n>>6|192,63&n|128)}else if(n<65536){if((t-=3)<0)break;i.push(n>>12|224,n>>6&63|128,63&n|128)}else{if(!(n<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;i.push(n>>18|240,n>>12&63|128,n>>6&63|128,63&n|128)}}return i}function B(e){return n.toByteArray(function(e){if((e=function(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,"")}(e).replace(j,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function G(e,t,n,r){for(var o=0;o<r&&!(o+n>=t.length||o>=e.length);++o)t[o+n]=e[o];return o}}).call(this)}).call(this,void 0!==n.g?n.g:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},e("buffer").Buffer)},{"base64-js":81,buffer:86,ieee754:88,isarray:89}],87:[function(e,t,n){function r(){this._events=this._events||{},this._maxListeners=this._maxListeners||void 0}function i(e){return"function"==typeof e}function a(e){return"object"===o(e)&&null!==e}function s(e){return void 0===e}t.exports=r,r.EventEmitter=r,r.prototype._events=void 0,r.prototype._maxListeners=void 0,r.defaultMaxListeners=10,r.prototype.setMaxListeners=function(e){if("number"!=typeof e||e<0||isNaN(e))throw TypeError("n must be a positive number");return this._maxListeners=e,this},r.prototype.emit=function(e){var t,n,r,o,c,u;if(this._events||(this._events={}),"error"===e&&(!this._events.error||a(this._events.error)&&!this._events.error.length)){if((t=arguments[1])instanceof Error)throw t;var l=new Error('Uncaught, unspecified "error" event. ('+t+")");throw l.context=t,l}if(s(n=this._events[e]))return!1;if(i(n))switch(arguments.length){case 1:n.call(this);break;case 2:n.call(this,arguments[1]);break;case 3:n.call(this,arguments[1],arguments[2]);break;default:o=Array.prototype.slice.call(arguments,1),n.apply(this,o)}else if(a(n))for(o=Array.prototype.slice.call(arguments,1),r=(u=n.slice()).length,c=0;c<r;c++)u[c].apply(this,o);return!0},r.prototype.addListener=function(e,t){var n;if(!i(t))throw TypeError("listener must be a function");return this._events||(this._events={}),this._events.newListener&&this.emit("newListener",e,i(t.listener)?t.listener:t),this._events[e]?a(this._events[e])?this._events[e].push(t):this._events[e]=[this._events[e],t]:this._events[e]=t,a(this._events[e])&&!this._events[e].warned&&(n=s(this._maxListeners)?r.defaultMaxListeners:this._maxListeners)&&n>0&&this._events[e].length>n&&(this._events[e].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[e].length),"function"==typeof console.trace&&console.trace()),this},r.prototype.on=r.prototype.addListener,r.prototype.once=function(e,t){if(!i(t))throw TypeError("listener must be a function");var n=!1;function r(){this.removeListener(e,r),n||(n=!0,t.apply(this,arguments))}return r.listener=t,this.on(e,r),this},r.prototype.removeListener=function(e,t){var n,r,o,s;if(!i(t))throw TypeError("listener must be a function");if(!this._events||!this._events[e])return this;if(o=(n=this._events[e]).length,r=-1,n===t||i(n.listener)&&n.listener===t)delete this._events[e],this._events.removeListener&&this.emit("removeListener",e,t);else if(a(n)){for(s=o;s-- >0;)if(n[s]===t||n[s].listener&&n[s].listener===t){r=s;break}if(r<0)return this;1===n.length?(n.length=0,delete this._events[e]):n.splice(r,1),this._events.removeListener&&this.emit("removeListener",e,t)}return this},r.prototype.removeAllListeners=function(e){var t,n;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[e]&&delete this._events[e],this;if(0===arguments.length){for(t in this._events)"removeListener"!==t&&this.removeAllListeners(t);return this.removeAllListeners("removeListener"),this._events={},this}if(i(n=this._events[e]))this.removeListener(e,n);else if(n)for(;n.length;)this.removeListener(e,n[n.length-1]);return delete this._events[e],this},r.prototype.listeners=function(e){return this._events&&this._events[e]?i(this._events[e])?[this._events[e]]:this._events[e].slice():[]},r.prototype.listenerCount=function(e){if(this._events){var t=this._events[e];if(i(t))return 1;if(t)return t.length}return 0},r.listenerCount=function(e,t){return e.listenerCount(t)}},{}],88:[function(e,t,n){n.read=function(e,t,n,r,o){var i,a,s=8*o-r-1,c=(1<<s)-1,u=c>>1,l=-7,p=n?o-1:0,d=n?-1:1,f=e[t+p];for(p+=d,i=f&(1<<-l)-1,f>>=-l,l+=s;l>0;i=256*i+e[t+p],p+=d,l-=8);for(a=i&(1<<-l)-1,i>>=-l,l+=r;l>0;a=256*a+e[t+p],p+=d,l-=8);if(0===i)i=1-u;else{if(i===c)return a?NaN:1/0*(f?-1:1);a+=Math.pow(2,r),i-=u}return(f?-1:1)*a*Math.pow(2,i-r)},n.write=function(e,t,n,r,o,i){var a,s,c,u=8*i-o-1,l=(1<<u)-1,p=l>>1,d=23===o?Math.pow(2,-24)-Math.pow(2,-77):0,f=r?0:i-1,h=r?1:-1,g=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,a=l):(a=Math.floor(Math.log(t)/Math.LN2),t*(c=Math.pow(2,-a))<1&&(a--,c*=2),(t+=a+p>=1?d/c:d*Math.pow(2,1-p))*c>=2&&(a++,c/=2),a+p>=l?(s=0,a=l):a+p>=1?(s=(t*c-1)*Math.pow(2,o),a+=p):(s=t*Math.pow(2,p-1)*Math.pow(2,o),a=0));o>=8;e[n+f]=255&s,f+=h,s/=256,o-=8);for(a=a<<o|s,u+=o;u>0;e[n+f]=255&a,f+=h,a/=256,u-=8);e[n+f-h]|=128*g}},{}],89:[function(e,t,n){var r={}.toString;t.exports=Array.isArray||function(e){return"[object Array]"==r.call(e)}},{}],90:[function(e,t,n){!function(e){"use strict";function t(e){return null!==e&&"[object Array]"===Object.prototype.toString.call(e)}function n(e){return null!==e&&"[object Object]"===Object.prototype.toString.call(e)}function r(e,o){if(e===o)return!0;if(Object.prototype.toString.call(e)!==Object.prototype.toString.call(o))return!1;if(!0===t(e)){if(e.length!==o.length)return!1;for(var i=0;i<e.length;i++)if(!1===r(e[i],o[i]))return!1;return!0}if(!0===n(e)){var a={};for(var s in e)if(hasOwnProperty.call(e,s)){if(!1===r(e[s],o[s]))return!1;a[s]=!0}for(var c in o)if(hasOwnProperty.call(o,c)&&!0!==a[c])return!1;return!0}return!1}function o(e){if(""===e||!1===e||null===e)return!0;if(t(e)&&0===e.length)return!0;if(n(e)){for(var r in e)if(e.hasOwnProperty(r))return!1;return!0}return!1}var i;i="function"==typeof String.prototype.trimLeft?function(e){return e.trimLeft()}:function(e){return e.match(/^\s*(.*)/)[1]};var a=0,s=2,c={0:"number",1:"any",2:"string",3:"array",4:"object",5:"boolean",6:"expression",7:"null",8:"Array<number>",9:"Array<string>"},u="EOF",l="UnquotedIdentifier",p="QuotedIdentifier",d="Rbracket",f="Rparen",h="Comma",g="Colon",m="Rbrace",v="Number",y="Current",b="Expref",E="Pipe",S="Or",C="And",T="EQ",I="GT",w="LT",A="GTE",_="LTE",R="NE",O="Flatten",L="Star",k="Filter",N="Dot",P="Not",D="Lbrace",x="Lbracket",M="Lparen",U="Literal",F={".":N,"*":L,",":h,":":g,"{":D,"}":m,"]":d,"(":M,")":f,"@":y},j={"<":!0,">":!0,"=":!0,"!":!0},q={" ":!0,"\t":!0,"\n":!0};function B(e){return e>="0"&&e<="9"||"-"===e}function G(){}G.prototype={tokenize:function(e){var t,n,r,o,i=[];for(this._current=0;this._current<e.length;)if((o=e[this._current])>="a"&&o<="z"||o>="A"&&o<="Z"||"_"===o)t=this._current,n=this._consumeUnquotedIdentifier(e),i.push({type:l,value:n,start:t});else if(void 0!==F[e[this._current]])i.push({type:F[e[this._current]],value:e[this._current],start:this._current}),this._current++;else if(B(e[this._current]))r=this._consumeNumber(e),i.push(r);else if("["===e[this._current])r=this._consumeLBracket(e),i.push(r);else if('"'===e[this._current])t=this._current,n=this._consumeQuotedIdentifier(e),i.push({type:p,value:n,start:t});else if("'"===e[this._current])t=this._current,n=this._consumeRawStringLiteral(e),i.push({type:U,value:n,start:t});else if("`"===e[this._current]){t=this._current;var a=this._consumeLiteral(e);i.push({type:U,value:a,start:t})}else if(void 0!==j[e[this._current]])i.push(this._consumeOperator(e));else if(void 0!==q[e[this._current]])this._current++;else if("&"===e[this._current])t=this._current,this._current++,"&"===e[this._current]?(this._current++,i.push({type:C,value:"&&",start:t})):i.push({type:b,value:"&",start:t});else{if("|"!==e[this._current]){var s=new Error("Unknown character:"+e[this._current]);throw s.name="LexerError",s}t=this._current,this._current++,"|"===e[this._current]?(this._current++,i.push({type:S,value:"||",start:t})):i.push({type:E,value:"|",start:t})}return i},_consumeUnquotedIdentifier:function(e){var t,n=this._current;for(this._current++;this._current<e.length&&((t=e[this._current])>="a"&&t<="z"||t>="A"&&t<="Z"||t>="0"&&t<="9"||"_"===t);)this._current++;return e.slice(n,this._current)},_consumeQuotedIdentifier:function(e){var t=this._current;this._current++;for(var n=e.length;'"'!==e[this._current]&&this._current<n;){var r=this._current;"\\"!==e[r]||"\\"!==e[r+1]&&'"'!==e[r+1]?r++:r+=2,this._current=r}return this._current++,JSON.parse(e.slice(t,this._current))},_consumeRawStringLiteral:function(e){var t=this._current;this._current++;for(var n=e.length;"'"!==e[this._current]&&this._current<n;){var r=this._current;"\\"!==e[r]||"\\"!==e[r+1]&&"'"!==e[r+1]?r++:r+=2,this._current=r}return this._current++,e.slice(t+1,this._current-1).replace("\\'","'")},_consumeNumber:function(e){var t=this._current;this._current++;for(var n=e.length;B(e[this._current])&&this._current<n;)this._current++;var r=parseInt(e.slice(t,this._current));return{type:v,value:r,start:t}},_consumeLBracket:function(e){var t=this._current;return this._current++,"?"===e[this._current]?(this._current++,{type:k,value:"[?",start:t}):"]"===e[this._current]?(this._current++,{type:O,value:"[]",start:t}):{type:x,value:"[",start:t}},_consumeOperator:function(e){var t=this._current,n=e[t];return this._current++,"!"===n?"="===e[this._current]?(this._current++,{type:R,value:"!=",start:t}):{type:P,value:"!",start:t}:"<"===n?"="===e[this._current]?(this._current++,{type:_,value:"<=",start:t}):{type:w,value:"<",start:t}:">"===n?"="===e[this._current]?(this._current++,{type:A,value:">=",start:t}):{type:I,value:">",start:t}:"="===n&&"="===e[this._current]?(this._current++,{type:T,value:"==",start:t}):void 0},_consumeLiteral:function(e){this._current++;for(var t,n=this._current,r=e.length;"`"!==e[this._current]&&this._current<r;){var o=this._current;"\\"!==e[o]||"\\"!==e[o+1]&&"`"!==e[o+1]?o++:o+=2,this._current=o}var a=i(e.slice(n,this._current));return a=a.replace("\\`","`"),t=this._looksLikeJSON(a)?JSON.parse(a):JSON.parse('"'+a+'"'),this._current++,t},_looksLikeJSON:function(e){if(""===e)return!1;if('[{"'.indexOf(e[0])>=0)return!0;if(["true","false","null"].indexOf(e)>=0)return!0;if(!("-0123456789".indexOf(e[0])>=0))return!1;try{return JSON.parse(e),!0}catch(e){return!1}}};var V={};function W(){}function H(e){this.runtime=e}function z(e){this._interpreter=e,this.functionTable={abs:{_func:this._functionAbs,_signature:[{types:[a]}]},avg:{_func:this._functionAvg,_signature:[{types:[8]}]},ceil:{_func:this._functionCeil,_signature:[{types:[a]}]},contains:{_func:this._functionContains,_signature:[{types:[s,3]},{types:[1]}]},ends_with:{_func:this._functionEndsWith,_signature:[{types:[s]},{types:[s]}]},floor:{_func:this._functionFloor,_signature:[{types:[a]}]},length:{_func:this._functionLength,_signature:[{types:[s,3,4]}]},map:{_func:this._functionMap,_signature:[{types:[6]},{types:[3]}]},max:{_func:this._functionMax,_signature:[{types:[8,9]}]},merge:{_func:this._functionMerge,_signature:[{types:[4],variadic:!0}]},max_by:{_func:this._functionMaxBy,_signature:[{types:[3]},{types:[6]}]},sum:{_func:this._functionSum,_signature:[{types:[8]}]},starts_with:{_func:this._functionStartsWith,_signature:[{types:[s]},{types:[s]}]},min:{_func:this._functionMin,_signature:[{types:[8,9]}]},min_by:{_func:this._functionMinBy,_signature:[{types:[3]},{types:[6]}]},type:{_func:this._functionType,_signature:[{types:[1]}]},keys:{_func:this._functionKeys,_signature:[{types:[4]}]},values:{_func:this._functionValues,_signature:[{types:[4]}]},sort:{_func:this._functionSort,_signature:[{types:[9,8]}]},sort_by:{_func:this._functionSortBy,_signature:[{types:[3]},{types:[6]}]},join:{_func:this._functionJoin,_signature:[{types:[s]},{types:[9]}]},reverse:{_func:this._functionReverse,_signature:[{types:[s,3]}]},to_array:{_func:this._functionToArray,_signature:[{types:[1]}]},to_string:{_func:this._functionToString,_signature:[{types:[1]}]},to_number:{_func:this._functionToNumber,_signature:[{types:[1]}]},not_null:{_func:this._functionNotNull,_signature:[{types:[1],variadic:!0}]}}}V[u]=0,V[l]=0,V[p]=0,V[d]=0,V[f]=0,V[h]=0,V[m]=0,V[v]=0,V[y]=0,V[b]=0,V[E]=1,V[S]=2,V[C]=3,V[T]=5,V[I]=5,V[w]=5,V[A]=5,V[_]=5,V[R]=5,V[O]=9,V[L]=20,V[k]=21,V[N]=40,V[P]=45,V[D]=50,V[x]=55,V[M]=60,W.prototype={parse:function(e){this._loadTokens(e),this.index=0;var t=this.expression(0);if(this._lookahead(0)!==u){var n=this._lookaheadToken(0),r=new Error("Unexpected token type: "+n.type+", value: "+n.value);throw r.name="ParserError",r}return t},_loadTokens:function(e){var t=(new G).tokenize(e);t.push({type:u,value:"",start:e.length}),this.tokens=t},expression:function(e){var t=this._lookaheadToken(0);this._advance();for(var n=this.nud(t),r=this._lookahead(0);e<V[r];)this._advance(),n=this.led(r,n),r=this._lookahead(0);return n},_lookahead:function(e){return this.tokens[this.index+e].type},_lookaheadToken:function(e){return this.tokens[this.index+e]},_advance:function(){this.index++},nud:function(e){var t,n;switch(e.type){case U:return{type:"Literal",value:e.value};case l:return{type:"Field",name:e.value};case p:var r={type:"Field",name:e.value};if(this._lookahead(0)===M)throw new Error("Quoted identifier not allowed for function names.");return r;case P:return{type:"NotExpression",children:[t=this.expression(V.Not)]};case L:return t=null,{type:"ValueProjection",children:[{type:"Identity"},t=this._lookahead(0)===d?{type:"Identity"}:this._parseProjectionRHS(V.Star)]};case k:return this.led(e.type,{type:"Identity"});case D:return this._parseMultiselectHash();case O:return{type:"Projection",children:[{type:O,children:[{type:"Identity"}]},t=this._parseProjectionRHS(V.Flatten)]};case x:return this._lookahead(0)===v||this._lookahead(0)===g?(t=this._parseIndexExpression(),this._projectIfSlice({type:"Identity"},t)):this._lookahead(0)===L&&this._lookahead(1)===d?(this._advance(),this._advance(),{type:"Projection",children:[{type:"Identity"},t=this._parseProjectionRHS(V.Star)]}):this._parseMultiselectList();case y:return{type:y};case b:return{type:"ExpressionReference",children:[n=this.expression(V.Expref)]};case M:for(var o=[];this._lookahead(0)!==f;)this._lookahead(0)===y?(n={type:y},this._advance()):n=this.expression(0),o.push(n);return this._match(f),o[0];default:this._errorToken(e)}},led:function(e,t){var n;switch(e){case N:var r=V.Dot;return this._lookahead(0)!==L?{type:"Subexpression",children:[t,n=this._parseDotRHS(r)]}:(this._advance(),{type:"ValueProjection",children:[t,n=this._parseProjectionRHS(r)]});case E:return n=this.expression(V.Pipe),{type:E,children:[t,n]};case S:return{type:"OrExpression",children:[t,n=this.expression(V.Or)]};case C:return{type:"AndExpression",children:[t,n=this.expression(V.And)]};case M:for(var o,i=t.name,a=[];this._lookahead(0)!==f;)this._lookahead(0)===y?(o={type:y},this._advance()):o=this.expression(0),this._lookahead(0)===h&&this._match(h),a.push(o);return this._match(f),{type:"Function",name:i,children:a};case k:var s=this.expression(0);return this._match(d),{type:"FilterProjection",children:[t,n=this._lookahead(0)===O?{type:"Identity"}:this._parseProjectionRHS(V.Filter),s]};case O:return{type:"Projection",children:[{type:O,children:[t]},this._parseProjectionRHS(V.Flatten)]};case T:case R:case I:case A:case w:case _:return this._parseComparator(t,e);case x:var c=this._lookaheadToken(0);return c.type===v||c.type===g?(n=this._parseIndexExpression(),this._projectIfSlice(t,n)):(this._match(L),this._match(d),{type:"Projection",children:[t,n=this._parseProjectionRHS(V.Star)]});default:this._errorToken(this._lookaheadToken(0))}},_match:function(e){if(this._lookahead(0)!==e){var t=this._lookaheadToken(0),n=new Error("Expected "+e+", got: "+t.type);throw n.name="ParserError",n}this._advance()},_errorToken:function(e){var t=new Error("Invalid token ("+e.type+'): "'+e.value+'"');throw t.name="ParserError",t},_parseIndexExpression:function(){if(this._lookahead(0)===g||this._lookahead(1)===g)return this._parseSliceExpression();var e={type:"Index",value:this._lookaheadToken(0).value};return this._advance(),this._match(d),e},_projectIfSlice:function(e,t){var n={type:"IndexExpression",children:[e,t]};return"Slice"===t.type?{type:"Projection",children:[n,this._parseProjectionRHS(V.Star)]}:n},_parseSliceExpression:function(){for(var e=[null,null,null],t=0,n=this._lookahead(0);n!==d&&t<3;){if(n===g)t++,this._advance();else{if(n!==v){var r=this._lookahead(0),o=new Error("Syntax error, unexpected token: "+r.value+"("+r.type+")");throw o.name="Parsererror",o}e[t]=this._lookaheadToken(0).value,this._advance()}n=this._lookahead(0)}return this._match(d),{type:"Slice",children:e}},_parseComparator:function(e,t){return{type:"Comparator",name:t,children:[e,this.expression(V[t])]}},_parseDotRHS:function(e){var t=this._lookahead(0);return[l,p,L].indexOf(t)>=0?this.expression(e):t===x?(this._match(x),this._parseMultiselectList()):t===D?(this._match(D),this._parseMultiselectHash()):void 0},_parseProjectionRHS:function(e){var t;if(V[this._lookahead(0)]<10)t={type:"Identity"};else if(this._lookahead(0)===x)t=this.expression(e);else if(this._lookahead(0)===k)t=this.expression(e);else{if(this._lookahead(0)!==N){var n=this._lookaheadToken(0),r=new Error("Sytanx error, unexpected token: "+n.value+"("+n.type+")");throw r.name="ParserError",r}this._match(N),t=this._parseDotRHS(e)}return t},_parseMultiselectList:function(){for(var e=[];this._lookahead(0)!==d;){var t=this.expression(0);if(e.push(t),this._lookahead(0)===h&&(this._match(h),this._lookahead(0)===d))throw new Error("Unexpected token Rbracket")}return this._match(d),{type:"MultiSelectList",children:e}},_parseMultiselectHash:function(){for(var e,t,n,r=[],o=[l,p];;){if(e=this._lookaheadToken(0),o.indexOf(e.type)<0)throw new Error("Expecting an identifier token, got: "+e.type);if(t=e.value,this._advance(),this._match(g),n={type:"KeyValuePair",name:t,value:this.expression(0)},r.push(n),this._lookahead(0)===h)this._match(h);else if(this._lookahead(0)===m){this._match(m);break}}return{type:"MultiSelectHash",children:r}}},H.prototype={search:function(e,t){return this.visit(e,t)},visit:function(e,i){var a,s,c,u,l,p,d,f,h;switch(e.type){case"Field":return null!==i&&n(i)?void 0===(p=i[e.name])?null:p:null;case"Subexpression":for(c=this.visit(e.children[0],i),h=1;h<e.children.length;h++)if(null===(c=this.visit(e.children[1],c)))return null;return c;case"IndexExpression":return d=this.visit(e.children[0],i),this.visit(e.children[1],d);case"Index":if(!t(i))return null;var g=e.value;return g<0&&(g=i.length+g),void 0===(c=i[g])&&(c=null),c;case"Slice":if(!t(i))return null;var m=e.children.slice(0),v=this.computeSliceParams(i.length,m),S=v[0],C=v[1],L=v[2];if(c=[],L>0)for(h=S;h<C;h+=L)c.push(i[h]);else for(h=S;h>C;h+=L)c.push(i[h]);return c;case"Projection":var k=this.visit(e.children[0],i);if(!t(k))return null;for(f=[],h=0;h<k.length;h++)null!==(s=this.visit(e.children[1],k[h]))&&f.push(s);return f;case"ValueProjection":if(!n(k=this.visit(e.children[0],i)))return null;f=[];var N=function(e){for(var t=Object.keys(e),n=[],r=0;r<t.length;r++)n.push(e[t[r]]);return n}(k);for(h=0;h<N.length;h++)null!==(s=this.visit(e.children[1],N[h]))&&f.push(s);return f;case"FilterProjection":if(!t(k=this.visit(e.children[0],i)))return null;var P=[],D=[];for(h=0;h<k.length;h++)o(a=this.visit(e.children[2],k[h]))||P.push(k[h]);for(var x=0;x<P.length;x++)null!==(s=this.visit(e.children[1],P[x]))&&D.push(s);return D;case"Comparator":switch(u=this.visit(e.children[0],i),l=this.visit(e.children[1],i),e.name){case T:c=r(u,l);break;case R:c=!r(u,l);break;case I:c=u>l;break;case A:c=u>=l;break;case w:c=u<l;break;case _:c=u<=l;break;default:throw new Error("Unknown comparator: "+e.name)}return c;case O:var M=this.visit(e.children[0],i);if(!t(M))return null;var U=[];for(h=0;h<M.length;h++)t(s=M[h])?U.push.apply(U,s):U.push(s);return U;case"Identity":return i;case"MultiSelectList":if(null===i)return null;for(f=[],h=0;h<e.children.length;h++)f.push(this.visit(e.children[h],i));return f;case"MultiSelectHash":if(null===i)return null;var F;for(f={},h=0;h<e.children.length;h++)f[(F=e.children[h]).name]=this.visit(F.value,i);return f;case"OrExpression":return o(a=this.visit(e.children[0],i))&&(a=this.visit(e.children[1],i)),a;case"AndExpression":return!0===o(u=this.visit(e.children[0],i))?u:this.visit(e.children[1],i);case"NotExpression":return o(u=this.visit(e.children[0],i));case"Literal":return e.value;case E:return d=this.visit(e.children[0],i),this.visit(e.children[1],d);case y:return i;case"Function":var j=[];for(h=0;h<e.children.length;h++)j.push(this.visit(e.children[h],i));return this.runtime.callFunction(e.name,j);case"ExpressionReference":var q=e.children[0];return q.jmespathType=b,q;default:throw new Error("Unknown node type: "+e.type)}},computeSliceParams:function(e,t){var n=t[0],r=t[1],o=t[2],i=[null,null,null];if(null===o)o=1;else if(0===o){var a=new Error("Invalid slice, step cannot be 0");throw a.name="RuntimeError",a}var s=o<0;return n=null===n?s?e-1:0:this.capSliceRange(e,n,o),r=null===r?s?-1:e:this.capSliceRange(e,r,o),i[0]=n,i[1]=r,i[2]=o,i},capSliceRange:function(e,t,n){return t<0?(t+=e)<0&&(t=n<0?-1:0):t>=e&&(t=n<0?e-1:e),t}},z.prototype={callFunction:function(e,t){var n=this.functionTable[e];if(void 0===n)throw new Error("Unknown function: "+e+"()");return this._validateArgs(e,t,n._signature),n._func.call(this,t)},_validateArgs:function(e,t,n){var r,o,i,a;if(n[n.length-1].variadic){if(t.length<n.length)throw r=1===n.length?" argument":" arguments",new Error("ArgumentError: "+e+"() takes at least"+n.length+r+" but received "+t.length)}else if(t.length!==n.length)throw r=1===n.length?" argument":" arguments",new Error("ArgumentError: "+e+"() takes "+n.length+r+" but received "+t.length);for(var s=0;s<n.length;s++){a=!1,o=n[s].types,i=this._getTypeName(t[s]);for(var u=0;u<o.length;u++)if(this._typeMatches(i,o[u],t[s])){a=!0;break}if(!a){var l=o.map((function(e){return c[e]})).join(",");throw new Error("TypeError: "+e+"() expected argument "+(s+1)+" to be type "+l+" but received type "+c[i]+" instead.")}}},_typeMatches:function(e,t,n){if(1===t)return!0;if(9!==t&&8!==t&&3!==t)return e===t;if(3===t)return 3===e;if(3===e){var r;8===t?r=a:9===t&&(r=s);for(var o=0;o<n.length;o++)if(!this._typeMatches(this._getTypeName(n[o]),r,n[o]))return!1;return!0}},_getTypeName:function(e){switch(Object.prototype.toString.call(e)){case"[object String]":return s;case"[object Number]":return a;case"[object Array]":return 3;case"[object Boolean]":return 5;case"[object Null]":return 7;case"[object Object]":return e.jmespathType===b?6:4}},_functionStartsWith:function(e){return 0===e[0].lastIndexOf(e[1])},_functionEndsWith:function(e){var t=e[0],n=e[1];return-1!==t.indexOf(n,t.length-n.length)},_functionReverse:function(e){if(this._getTypeName(e[0])===s){for(var t=e[0],n="",r=t.length-1;r>=0;r--)n+=t[r];return n}var o=e[0].slice(0);return o.reverse(),o},_functionAbs:function(e){return Math.abs(e[0])},_functionCeil:function(e){return Math.ceil(e[0])},_functionAvg:function(e){for(var t=0,n=e[0],r=0;r<n.length;r++)t+=n[r];return t/n.length},_functionContains:function(e){return e[0].indexOf(e[1])>=0},_functionFloor:function(e){return Math.floor(e[0])},_functionLength:function(e){return n(e[0])?Object.keys(e[0]).length:e[0].length},_functionMap:function(e){for(var t=[],n=this._interpreter,r=e[0],o=e[1],i=0;i<o.length;i++)t.push(n.visit(r,o[i]));return t},_functionMerge:function(e){for(var t={},n=0;n<e.length;n++){var r=e[n];for(var o in r)t[o]=r[o]}return t},_functionMax:function(e){if(e[0].length>0){if(this._getTypeName(e[0][0])===a)return Math.max.apply(Math,e[0]);for(var t=e[0],n=t[0],r=1;r<t.length;r++)n.localeCompare(t[r])<0&&(n=t[r]);return n}return null},_functionMin:function(e){if(e[0].length>0){if(this._getTypeName(e[0][0])===a)return Math.min.apply(Math,e[0]);for(var t=e[0],n=t[0],r=1;r<t.length;r++)t[r].localeCompare(n)<0&&(n=t[r]);return n}return null},_functionSum:function(e){for(var t=0,n=e[0],r=0;r<n.length;r++)t+=n[r];return t},_functionType:function(e){switch(this._getTypeName(e[0])){case a:return"number";case s:return"string";case 3:return"array";case 4:return"object";case 5:return"boolean";case 6:return"expref";case 7:return"null"}},_functionKeys:function(e){return Object.keys(e[0])},_functionValues:function(e){for(var t=e[0],n=Object.keys(t),r=[],o=0;o<n.length;o++)r.push(t[n[o]]);return r},_functionJoin:function(e){var t=e[0];return e[1].join(t)},_functionToArray:function(e){return 3===this._getTypeName(e[0])?e[0]:[e[0]]},_functionToString:function(e){return this._getTypeName(e[0])===s?e[0]:JSON.stringify(e[0])},_functionToNumber:function(e){var t,n=this._getTypeName(e[0]);return n===a?e[0]:n!==s||(t=+e[0],isNaN(t))?null:t},_functionNotNull:function(e){for(var t=0;t<e.length;t++)if(7!==this._getTypeName(e[t]))return e[t];return null},_functionSort:function(e){var t=e[0].slice(0);return t.sort(),t},_functionSortBy:function(e){var t=e[0].slice(0);if(0===t.length)return t;var n=this._interpreter,r=e[1],o=this._getTypeName(n.visit(r,t[0]));if([a,s].indexOf(o)<0)throw new Error("TypeError");for(var i=this,c=[],u=0;u<t.length;u++)c.push([u,t[u]]);c.sort((function(e,t){var a=n.visit(r,e[1]),s=n.visit(r,t[1]);if(i._getTypeName(a)!==o)throw new Error("TypeError: expected "+o+", received "+i._getTypeName(a));if(i._getTypeName(s)!==o)throw new Error("TypeError: expected "+o+", received "+i._getTypeName(s));return a>s?1:a<s?-1:e[0]-t[0]}));for(var l=0;l<c.length;l++)t[l]=c[l][1];return t},_functionMaxBy:function(e){for(var t,n,r=e[1],o=e[0],i=this.createKeyFunction(r,[a,s]),c=-1/0,u=0;u<o.length;u++)(n=i(o[u]))>c&&(c=n,t=o[u]);return t},_functionMinBy:function(e){for(var t,n,r=e[1],o=e[0],i=this.createKeyFunction(r,[a,s]),c=1/0,u=0;u<o.length;u++)(n=i(o[u]))<c&&(c=n,t=o[u]);return t},createKeyFunction:function(e,t){var n=this,r=this._interpreter;return function(o){var i=r.visit(e,o);if(t.indexOf(n._getTypeName(i))<0){var a="TypeError: expected one of "+t+", received "+n._getTypeName(i);throw new Error(a)}return i}}},e.tokenize=function(e){return(new G).tokenize(e)},e.compile=function(e){return(new W).parse(e)},e.search=function(e,t){var n=new W,r=new z,o=new H(r);r._interpreter=o;var i=n.parse(t);return o.search(i,e)},e.strictDeepEqual=r}(void 0===n?this.jmespath={}:n)},{}],91:[function(e,t,n){var r,o,i=t.exports={};function a(){throw new Error("setTimeout has not been defined")}function s(){throw new Error("clearTimeout has not been defined")}function c(e){if(r===setTimeout)return setTimeout(e,0);if((r===a||!r)&&setTimeout)return r=setTimeout,setTimeout(e,0);try{return r(e,0)}catch(t){try{return r.call(null,e,0)}catch(t){return r.call(this,e,0)}}}!function(){try{r="function"==typeof setTimeout?setTimeout:a}catch(e){r=a}try{o="function"==typeof clearTimeout?clearTimeout:s}catch(e){o=s}}();var u,l=[],p=!1,d=-1;function f(){p&&u&&(p=!1,u.length?l=u.concat(l):d=-1,l.length&&h())}function h(){if(!p){var e=c(f);p=!0;for(var t=l.length;t;){for(u=l,l=[];++d<t;)u&&u[d].run();d=-1,t=l.length}u=null,p=!1,function(e){if(o===clearTimeout)return clearTimeout(e);if((o===s||!o)&&clearTimeout)return o=clearTimeout,clearTimeout(e);try{return o(e)}catch(t){try{return o.call(null,e)}catch(t){return o.call(this,e)}}}(e)}}function g(e,t){this.fun=e,this.array=t}function m(){}i.nextTick=function(e){var t=new Array(arguments.length-1);if(arguments.length>1)for(var n=1;n<arguments.length;n++)t[n-1]=arguments[n];l.push(new g(e,t)),1!==l.length||p||c(h)},g.prototype.run=function(){this.fun.apply(null,this.array)},i.title="browser",i.browser=!0,i.env={},i.argv=[],i.version="",i.versions={},i.on=m,i.addListener=m,i.once=m,i.off=m,i.removeListener=m,i.removeAllListeners=m,i.emit=m,i.prependListener=m,i.prependOnceListener=m,i.listeners=function(e){return[]},i.binding=function(e){throw new Error("process.binding is not supported")},i.cwd=function(){return"/"},i.chdir=function(e){throw new Error("process.chdir is not supported")},i.umask=function(){return 0}},{}],92:[function(e,t,i){(function(e){(function(){!function(a){var s="object"==o(i)&&i&&!i.nodeType&&i,c="object"==o(t)&&t&&!t.nodeType&&t,u="object"==o(e)&&e;u.global!==u&&u.window!==u&&u.self!==u||(a=u);var l,p,d=2147483647,f=36,h=/^xn--/,g=/[^\x20-\x7E]/,m=/[\x2E\u3002\uFF0E\uFF61]/g,v={overflow:"Overflow: input needs wider integers to process","not-basic":"Illegal input >= 0x80 (not a basic code point)","invalid-input":"Invalid input"},y=Math.floor,b=String.fromCharCode;function E(e){throw new RangeError(v[e])}function S(e,t){for(var n=e.length,r=[];n--;)r[n]=t(e[n]);return r}function C(e,t){var n=e.split("@"),r="";return n.length>1&&(r=n[0]+"@",e=n[1]),r+S((e=e.replace(m,".")).split("."),t).join(".")}function T(e){for(var t,n,r=[],o=0,i=e.length;o<i;)(t=e.charCodeAt(o++))>=55296&&t<=56319&&o<i?56320==(64512&(n=e.charCodeAt(o++)))?r.push(((1023&t)<<10)+(1023&n)+65536):(r.push(t),o--):r.push(t);return r}function I(e){return S(e,(function(e){var t="";return e>65535&&(t+=b((e-=65536)>>>10&1023|55296),e=56320|1023&e),t+=b(e)})).join("")}function w(e,t){return e+22+75*(e<26)-((0!=t)<<5)}function A(e,t,n){var r=0;for(e=n?y(e/700):e>>1,e+=y(e/t);e>455;r+=f)e=y(e/35);return y(r+36*e/(e+38))}function _(e){var t,n,r,o,i,a,s,c,u,l,p,h=[],g=e.length,m=0,v=128,b=72;for((n=e.lastIndexOf("-"))<0&&(n=0),r=0;r<n;++r)e.charCodeAt(r)>=128&&E("not-basic"),h.push(e.charCodeAt(r));for(o=n>0?n+1:0;o<g;){for(i=m,a=1,s=f;o>=g&&E("invalid-input"),((c=(p=e.charCodeAt(o++))-48<10?p-22:p-65<26?p-65:p-97<26?p-97:f)>=f||c>y((d-m)/a))&&E("overflow"),m+=c*a,!(c<(u=s<=b?1:s>=b+26?26:s-b));s+=f)a>y(d/(l=f-u))&&E("overflow"),a*=l;b=A(m-i,t=h.length+1,0==i),y(m/t)>d-v&&E("overflow"),v+=y(m/t),m%=t,h.splice(m++,0,v)}return I(h)}function R(e){var t,n,r,o,i,a,s,c,u,l,p,h,g,m,v,S=[];for(h=(e=T(e)).length,t=128,n=0,i=72,a=0;a<h;++a)(p=e[a])<128&&S.push(b(p));for(r=o=S.length,o&&S.push("-");r<h;){for(s=d,a=0;a<h;++a)(p=e[a])>=t&&p<s&&(s=p);for(s-t>y((d-n)/(g=r+1))&&E("overflow"),n+=(s-t)*g,t=s,a=0;a<h;++a)if((p=e[a])<t&&++n>d&&E("overflow"),p==t){for(c=n,u=f;!(c<(l=u<=i?1:u>=i+26?26:u-i));u+=f)v=c-l,m=f-l,S.push(b(w(l+v%m,0))),c=y(v/m);S.push(b(w(c,0))),i=A(n,g,r==o),n=0,++r}++n,++t}return S.join("")}if(l={version:"1.4.1",ucs2:{decode:T,encode:I},decode:_,encode:R,toASCII:function(e){return C(e,(function(e){return g.test(e)?"xn--"+R(e):e}))},toUnicode:function(e){return C(e,(function(e){return h.test(e)?_(e.slice(4).toLowerCase()):e}))}},"object"==o(n.amdO)&&n.amdO)void 0===(r=function(){return l}.call(i,n,i,t))||(t.exports=r);else if(s&&c)if(t.exports==s)c.exports=l;else for(p in l)l.hasOwnProperty(p)&&(s[p]=l[p]);else a.punycode=l}(this)}).call(this)}).call(this,void 0!==n.g?n.g:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],93:[function(e,t,n){"use strict";function r(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.exports=function(e,t,n,i){t=t||"&",n=n||"=";var a={};if("string"!=typeof e||0===e.length)return a;var s=/\+/g;e=e.split(t);var c=1e3;i&&"number"==typeof i.maxKeys&&(c=i.maxKeys);var u=e.length;c>0&&u>c&&(u=c);for(var l=0;l<u;++l){var p,d,f,h,g=e[l].replace(s,"%20"),m=g.indexOf(n);m>=0?(p=g.substr(0,m),d=g.substr(m+1)):(p=g,d=""),f=decodeURIComponent(p),h=decodeURIComponent(d),r(a,f)?o(a[f])?a[f].push(h):a[f]=[a[f],h]:a[f]=h}return a};var o=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)}},{}],94:[function(e,t,n){"use strict";var r=function(e){switch(o(e)){case"string":return e;case"boolean":return e?"true":"false";case"number":return isFinite(e)?e:"";default:return""}};t.exports=function(e,t,n,c){return t=t||"&",n=n||"=",null===e&&(e=void 0),"object"===o(e)?a(s(e),(function(o){var s=encodeURIComponent(r(o))+n;return i(e[o])?a(e[o],(function(e){return s+encodeURIComponent(r(e))})).join(t):s+encodeURIComponent(r(e[o]))})).join(t):c?encodeURIComponent(r(c))+n+encodeURIComponent(r(e)):""};var i=Array.isArray||function(e){return"[object Array]"===Object.prototype.toString.call(e)};function a(e,t){if(e.map)return e.map(t);for(var n=[],r=0;r<e.length;r++)n.push(t(e[r],r));return n}var s=Object.keys||function(e){var t=[];for(var n in e)Object.prototype.hasOwnProperty.call(e,n)&&t.push(n);return t}},{}],95:[function(e,t,n){"use strict";n.decode=n.parse=e("./decode"),n.encode=n.stringify=e("./encode")},{"./decode":93,"./encode":94}],96:[function(e,t,n){"use strict";function r(e,t){return Object.prototype.hasOwnProperty.call(e,t)}t.exports=function(e,t,n,o){t=t||"&",n=n||"=";var i={};if("string"!=typeof e||0===e.length)return i;var a=/\+/g;e=e.split(t);var s=1e3;o&&"number"==typeof o.maxKeys&&(s=o.maxKeys);var c=e.length;s>0&&c>s&&(c=s);for(var u=0;u<c;++u){var l,p,d,f,h=e[u].replace(a,"%20"),g=h.indexOf(n);g>=0?(l=h.substr(0,g),p=h.substr(g+1)):(l=h,p=""),d=decodeURIComponent(l),f=decodeURIComponent(p),r(i,d)?Array.isArray(i[d])?i[d].push(f):i[d]=[i[d],f]:i[d]=f}return i}},{}],97:[function(e,t,n){"use strict";var r=function(e){switch(o(e)){case"string":return e;case"boolean":return e?"true":"false";case"number":return isFinite(e)?e:"";default:return""}};t.exports=function(e,t,n,i){return t=t||"&",n=n||"=",null===e&&(e=void 0),"object"===o(e)?Object.keys(e).map((function(o){var i=encodeURIComponent(r(o))+n;return Array.isArray(e[o])?e[o].map((function(e){return i+encodeURIComponent(r(e))})).join(t):i+encodeURIComponent(r(e[o]))})).join(t):i?encodeURIComponent(r(i))+n+encodeURIComponent(r(e)):""}},{}],98:[function(e,t,n){arguments[4][95][0].apply(n,arguments)},{"./decode":96,"./encode":97,dup:95}],99:[function(e,t,n){(function(t,r){(function(){var o=e("process/browser.js").nextTick,i=Function.prototype.apply,a=Array.prototype.slice,s={},c=0;function u(e,t){this._id=e,this._clearFn=t}n.setTimeout=function(){return new u(i.call(setTimeout,window,arguments),clearTimeout)},n.setInterval=function(){return new u(i.call(setInterval,window,arguments),clearInterval)},n.clearTimeout=n.clearInterval=function(e){e.close()},u.prototype.unref=u.prototype.ref=function(){},u.prototype.close=function(){this._clearFn.call(window,this._id)},n.enroll=function(e,t){clearTimeout(e._idleTimeoutId),e._idleTimeout=t},n.unenroll=function(e){clearTimeout(e._idleTimeoutId),e._idleTimeout=-1},n._unrefActive=n.active=function(e){clearTimeout(e._idleTimeoutId);var t=e._idleTimeout;t>=0&&(e._idleTimeoutId=setTimeout((function(){e._onTimeout&&e._onTimeout()}),t))},n.setImmediate="function"==typeof t?t:function(e){var t=c++,r=!(arguments.length<2)&&a.call(arguments,1);return s[t]=!0,o((function(){s[t]&&(r?e.apply(null,r):e.call(null),n.clearImmediate(t))})),t},n.clearImmediate="function"==typeof r?r:function(e){delete s[e]}}).call(this)}).call(this,e("timers").setImmediate,e("timers").clearImmediate)},{"process/browser.js":91,timers:99}],100:[function(e,t,n){var r=e("punycode");function i(){this.protocol=null,this.slashes=null,this.auth=null,this.host=null,this.port=null,this.hostname=null,this.hash=null,this.search=null,this.query=null,this.pathname=null,this.path=null,this.href=null}n.parse=y,n.resolve=function(e,t){return y(e,!1,!0).resolve(t)},n.resolveObject=function(e,t){return e?y(e,!1,!0).resolveObject(t):t},n.format=function(e){return b(e)&&(e=y(e)),e instanceof i?e.format():i.prototype.format.call(e)},n.Url=i;var a=/^([a-z0-9.+-]+:)/i,s=/:[0-9]*$/,c=["{","}","|","\\","^","`"].concat(["<",">",'"',"`"," ","\r","\n","\t"]),u=["'"].concat(c),l=["%","/","?",";","#"].concat(u),p=["/","?","#"],d=/^[a-z0-9A-Z_-]{0,63}$/,f=/^([a-z0-9A-Z_-]{0,63})(.*)$/,h={javascript:!0,"javascript:":!0},g={javascript:!0,"javascript:":!0},m={http:!0,https:!0,ftp:!0,gopher:!0,file:!0,"http:":!0,"https:":!0,"ftp:":!0,"gopher:":!0,"file:":!0},v=e("querystring");function y(e,t,n){if(e&&E(e)&&e instanceof i)return e;var r=new i;return r.parse(e,t,n),r}function b(e){return"string"==typeof e}function E(e){return"object"===o(e)&&null!==e}function S(e){return null===e}i.prototype.parse=function(e,t,n){if(!b(e))throw new TypeError("Parameter 'url' must be a string, not "+o(e));var i=e;i=i.trim();var s=a.exec(i);if(s){var c=(s=s[0]).toLowerCase();this.protocol=c,i=i.substr(s.length)}if(n||s||i.match(/^\/\/[^@\/]+@[^@\/]+/)){var y="//"===i.substr(0,2);!y||s&&g[s]||(i=i.substr(2),this.slashes=!0)}if(!g[s]&&(y||s&&!m[s])){for(var E,S,C=-1,T=0;T<p.length;T++)-1!==(I=i.indexOf(p[T]))&&(-1===C||I<C)&&(C=I);for(-1!==(S=-1===C?i.lastIndexOf("@"):i.lastIndexOf("@",C))&&(E=i.slice(0,S),i=i.slice(S+1),this.auth=decodeURIComponent(E)),C=-1,T=0;T<l.length;T++){var I;-1!==(I=i.indexOf(l[T]))&&(-1===C||I<C)&&(C=I)}-1===C&&(C=i.length),this.host=i.slice(0,C),i=i.slice(C),this.parseHost(),this.hostname=this.hostname||"";var w="["===this.hostname[0]&&"]"===this.hostname[this.hostname.length-1];if(!w)for(var A=this.hostname.split(/\./),_=(T=0,A.length);T<_;T++){var R=A[T];if(R&&!R.match(d)){for(var O="",L=0,k=R.length;L<k;L++)R.charCodeAt(L)>127?O+="x":O+=R[L];if(!O.match(d)){var N=A.slice(0,T),P=A.slice(T+1),D=R.match(f);D&&(N.push(D[1]),P.unshift(D[2])),P.length&&(i="/"+P.join(".")+i),this.hostname=N.join(".");break}}}if(this.hostname.length>255?this.hostname="":this.hostname=this.hostname.toLowerCase(),!w){var x=this.hostname.split("."),M=[];for(T=0;T<x.length;++T){var U=x[T];M.push(U.match(/[^A-Za-z0-9_-]/)?"xn--"+r.encode(U):U)}this.hostname=M.join(".")}var F=this.port?":"+this.port:"",j=this.hostname||"";this.host=j+F,this.href+=this.host,w&&(this.hostname=this.hostname.substr(1,this.hostname.length-2),"/"!==i[0]&&(i="/"+i))}if(!h[c])for(T=0,_=u.length;T<_;T++){var q=u[T],B=encodeURIComponent(q);B===q&&(B=escape(q)),i=i.split(q).join(B)}var G=i.indexOf("#");-1!==G&&(this.hash=i.substr(G),i=i.slice(0,G));var V=i.indexOf("?");return-1!==V?(this.search=i.substr(V),this.query=i.substr(V+1),t&&(this.query=v.parse(this.query)),i=i.slice(0,V)):t&&(this.search="",this.query={}),i&&(this.pathname=i),m[c]&&this.hostname&&!this.pathname&&(this.pathname="/"),(this.pathname||this.search)&&(F=this.pathname||"",U=this.search||"",this.path=F+U),this.href=this.format(),this},i.prototype.format=function(){var e=this.auth||"";e&&(e=(e=encodeURIComponent(e)).replace(/%3A/i,":"),e+="@");var t=this.protocol||"",n=this.pathname||"",r=this.hash||"",o=!1,i="";this.host?o=e+this.host:this.hostname&&(o=e+(-1===this.hostname.indexOf(":")?this.hostname:"["+this.hostname+"]"),this.port&&(o+=":"+this.port)),this.query&&E(this.query)&&Object.keys(this.query).length&&(i=v.stringify(this.query));var a=this.search||i&&"?"+i||"";return t&&":"!==t.substr(-1)&&(t+=":"),this.slashes||(!t||m[t])&&!1!==o?(o="//"+(o||""),n&&"/"!==n.charAt(0)&&(n="/"+n)):o||(o=""),r&&"#"!==r.charAt(0)&&(r="#"+r),a&&"?"!==a.charAt(0)&&(a="?"+a),t+o+(n=n.replace(/[?#]/g,(function(e){return encodeURIComponent(e)})))+(a=a.replace("#","%23"))+r},i.prototype.resolve=function(e){return this.resolveObject(y(e,!1,!0)).format()},i.prototype.resolveObject=function(e){if(b(e)){var t=new i;t.parse(e,!1,!0),e=t}var n=new i;if(Object.keys(this).forEach((function(e){n[e]=this[e]}),this),n.hash=e.hash,""===e.href)return n.href=n.format(),n;if(e.slashes&&!e.protocol)return Object.keys(e).forEach((function(t){"protocol"!==t&&(n[t]=e[t])})),m[n.protocol]&&n.hostname&&!n.pathname&&(n.path=n.pathname="/"),n.href=n.format(),n;if(e.protocol&&e.protocol!==n.protocol){if(!m[e.protocol])return Object.keys(e).forEach((function(t){n[t]=e[t]})),n.href=n.format(),n;if(n.protocol=e.protocol,e.host||g[e.protocol])n.pathname=e.pathname;else{for(var r=(e.pathname||"").split("/");r.length&&!(e.host=r.shift()););e.host||(e.host=""),e.hostname||(e.hostname=""),""!==r[0]&&r.unshift(""),r.length<2&&r.unshift(""),n.pathname=r.join("/")}if(n.search=e.search,n.query=e.query,n.host=e.host||"",n.auth=e.auth,n.hostname=e.hostname||e.host,n.port=e.port,n.pathname||n.search){var o=n.pathname||"",a=n.search||"";n.path=o+a}return n.slashes=n.slashes||e.slashes,n.href=n.format(),n}var s=n.pathname&&"/"===n.pathname.charAt(0),c=e.host||e.pathname&&"/"===e.pathname.charAt(0),u=c||s||n.host&&e.pathname,l=u,p=n.pathname&&n.pathname.split("/")||[],d=(r=e.pathname&&e.pathname.split("/")||[],n.protocol&&!m[n.protocol]);if(d&&(n.hostname="",n.port=null,n.host&&(""===p[0]?p[0]=n.host:p.unshift(n.host)),n.host="",e.protocol&&(e.hostname=null,e.port=null,e.host&&(""===r[0]?r[0]=e.host:r.unshift(e.host)),e.host=null),u=u&&(""===r[0]||""===p[0])),c)n.host=e.host||""===e.host?e.host:n.host,n.hostname=e.hostname||""===e.hostname?e.hostname:n.hostname,n.search=e.search,n.query=e.query,p=r;else if(r.length)p||(p=[]),p.pop(),p=p.concat(r),n.search=e.search,n.query=e.query;else if(null!=e.search)return d&&(n.hostname=n.host=p.shift(),(E=!!(n.host&&n.host.indexOf("@")>0)&&n.host.split("@"))&&(n.auth=E.shift(),n.host=n.hostname=E.shift())),n.search=e.search,n.query=e.query,S(n.pathname)&&S(n.search)||(n.path=(n.pathname?n.pathname:"")+(n.search?n.search:"")),n.href=n.format(),n;if(!p.length)return n.pathname=null,n.search?n.path="/"+n.search:n.path=null,n.href=n.format(),n;for(var f=p.slice(-1)[0],h=(n.host||e.host)&&("."===f||".."===f)||""===f,v=0,y=p.length;y>=0;y--)"."==(f=p[y])?p.splice(y,1):".."===f?(p.splice(y,1),v++):v&&(p.splice(y,1),v--);if(!u&&!l)for(;v--;v)p.unshift("..");!u||""===p[0]||p[0]&&"/"===p[0].charAt(0)||p.unshift(""),h&&"/"!==p.join("/").substr(-1)&&p.push("");var E,C=""===p[0]||p[0]&&"/"===p[0].charAt(0);return d&&(n.hostname=n.host=C?"":p.length?p.shift():"",(E=!!(n.host&&n.host.indexOf("@")>0)&&n.host.split("@"))&&(n.auth=E.shift(),n.host=n.hostname=E.shift())),(u=u||n.host&&p.length)&&!C&&p.unshift(""),p.length?n.pathname=p.join("/"):(n.pathname=null,n.path=null),S(n.pathname)&&S(n.search)||(n.path=(n.pathname?n.pathname:"")+(n.search?n.search:"")),n.auth=e.auth||n.auth,n.slashes=n.slashes||e.slashes,n.href=n.format(),n},i.prototype.parseHost=function(){var e=this.host,t=s.exec(e);t&&(":"!==(t=t[0])&&(this.port=t.substr(1)),e=e.substr(0,e.length-t.length)),e&&(this.hostname=e)}},{punycode:92,querystring:95}],101:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;for(var r=[],o=0;o<256;++o)r[o]=(o+256).toString(16).substr(1);var i=function(e,t){var n=t||0,o=r;return[o[e[n++]],o[e[n++]],o[e[n++]],o[e[n++]],"-",o[e[n++]],o[e[n++]],"-",o[e[n++]],o[e[n++]],"-",o[e[n++]],o[e[n++]],"-",o[e[n++]],o[e[n++]],o[e[n++]],o[e[n++]],o[e[n++]],o[e[n++]]].join("")};n.default=i},{}],102:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),Object.defineProperty(n,"v1",{enumerable:!0,get:function(){return r.default}}),Object.defineProperty(n,"v3",{enumerable:!0,get:function(){return o.default}}),Object.defineProperty(n,"v4",{enumerable:!0,get:function(){return i.default}}),Object.defineProperty(n,"v5",{enumerable:!0,get:function(){return a.default}});var r=s(e("./v1.js")),o=s(e("./v3.js")),i=s(e("./v4.js")),a=s(e("./v5.js"));function s(e){return e&&e.__esModule?e:{default:e}}},{"./v1.js":106,"./v3.js":107,"./v4.js":109,"./v5.js":110}],103:[function(e,t,n){"use strict";function r(e,t){var n=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(n>>16)<<16|65535&n}function o(e,t,n,o,i,a){return r((s=r(r(t,e),r(o,a)))<<(c=i)|s>>>32-c,n);var s,c}function i(e,t,n,r,i,a,s){return o(t&n|~t&r,e,t,i,a,s)}function a(e,t,n,r,i,a,s){return o(t&r|n&~r,e,t,i,a,s)}function s(e,t,n,r,i,a,s){return o(t^n^r,e,t,i,a,s)}function c(e,t,n,r,i,a,s){return o(n^(t|~r),e,t,i,a,s)}Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var u=function(e){if("string"==typeof e){var t=unescape(encodeURIComponent(e));e=new Array(t.length);for(var n=0;n<t.length;n++)e[n]=t.charCodeAt(n)}return function(e){var t,n,r,o=[],i=32*e.length,a="0123456789abcdef";for(t=0;t<i;t+=8)n=e[t>>5]>>>t%32&255,r=parseInt(a.charAt(n>>>4&15)+a.charAt(15&n),16),o.push(r);return o}(function(e,t){var n,o,u,l,p;e[t>>5]|=128<<t%32,e[14+(t+64>>>9<<4)]=t;var d=1732584193,f=-271733879,h=-1732584194,g=271733878;for(n=0;n<e.length;n+=16)o=d,u=f,l=h,p=g,d=i(d,f,h,g,e[n],7,-680876936),g=i(g,d,f,h,e[n+1],12,-389564586),h=i(h,g,d,f,e[n+2],17,606105819),f=i(f,h,g,d,e[n+3],22,-1044525330),d=i(d,f,h,g,e[n+4],7,-176418897),g=i(g,d,f,h,e[n+5],12,1200080426),h=i(h,g,d,f,e[n+6],17,-1473231341),f=i(f,h,g,d,e[n+7],22,-45705983),d=i(d,f,h,g,e[n+8],7,1770035416),g=i(g,d,f,h,e[n+9],12,-1958414417),h=i(h,g,d,f,e[n+10],17,-42063),f=i(f,h,g,d,e[n+11],22,-1990404162),d=i(d,f,h,g,e[n+12],7,1804603682),g=i(g,d,f,h,e[n+13],12,-40341101),h=i(h,g,d,f,e[n+14],17,-1502002290),d=a(d,f=i(f,h,g,d,e[n+15],22,1236535329),h,g,e[n+1],5,-165796510),g=a(g,d,f,h,e[n+6],9,-1069501632),h=a(h,g,d,f,e[n+11],14,643717713),f=a(f,h,g,d,e[n],20,-373897302),d=a(d,f,h,g,e[n+5],5,-701558691),g=a(g,d,f,h,e[n+10],9,38016083),h=a(h,g,d,f,e[n+15],14,-660478335),f=a(f,h,g,d,e[n+4],20,-405537848),d=a(d,f,h,g,e[n+9],5,568446438),g=a(g,d,f,h,e[n+14],9,-1019803690),h=a(h,g,d,f,e[n+3],14,-187363961),f=a(f,h,g,d,e[n+8],20,1163531501),d=a(d,f,h,g,e[n+13],5,-1444681467),g=a(g,d,f,h,e[n+2],9,-51403784),h=a(h,g,d,f,e[n+7],14,1735328473),d=s(d,f=a(f,h,g,d,e[n+12],20,-1926607734),h,g,e[n+5],4,-378558),g=s(g,d,f,h,e[n+8],11,-2022574463),h=s(h,g,d,f,e[n+11],16,1839030562),f=s(f,h,g,d,e[n+14],23,-35309556),d=s(d,f,h,g,e[n+1],4,-1530992060),g=s(g,d,f,h,e[n+4],11,1272893353),h=s(h,g,d,f,e[n+7],16,-155497632),f=s(f,h,g,d,e[n+10],23,-1094730640),d=s(d,f,h,g,e[n+13],4,681279174),g=s(g,d,f,h,e[n],11,-358537222),h=s(h,g,d,f,e[n+3],16,-722521979),f=s(f,h,g,d,e[n+6],23,76029189),d=s(d,f,h,g,e[n+9],4,-640364487),g=s(g,d,f,h,e[n+12],11,-421815835),h=s(h,g,d,f,e[n+15],16,530742520),d=c(d,f=s(f,h,g,d,e[n+2],23,-995338651),h,g,e[n],6,-198630844),g=c(g,d,f,h,e[n+7],10,1126891415),h=c(h,g,d,f,e[n+14],15,-1416354905),f=c(f,h,g,d,e[n+5],21,-57434055),d=c(d,f,h,g,e[n+12],6,1700485571),g=c(g,d,f,h,e[n+3],10,-1894986606),h=c(h,g,d,f,e[n+10],15,-1051523),f=c(f,h,g,d,e[n+1],21,-2054922799),d=c(d,f,h,g,e[n+8],6,1873313359),g=c(g,d,f,h,e[n+15],10,-30611744),h=c(h,g,d,f,e[n+6],15,-1560198380),f=c(f,h,g,d,e[n+13],21,1309151649),d=c(d,f,h,g,e[n+4],6,-145523070),g=c(g,d,f,h,e[n+11],10,-1120210379),h=c(h,g,d,f,e[n+2],15,718787259),f=c(f,h,g,d,e[n+9],21,-343485551),d=r(d,o),f=r(f,u),h=r(h,l),g=r(g,p);return[d,f,h,g]}(function(e){var t,n=[];for(n[(e.length>>2)-1]=void 0,t=0;t<n.length;t+=1)n[t]=0;var r=8*e.length;for(t=0;t<r;t+=8)n[t>>5]|=(255&e[t/8])<<t%32;return n}(e),8*e.length))};n.default=u},{}],104:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=function(){if(!r)throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");return r(o)};var r="undefined"!=typeof crypto&&crypto.getRandomValues&&crypto.getRandomValues.bind(crypto)||"undefined"!=typeof msCrypto&&"function"==typeof msCrypto.getRandomValues&&msCrypto.getRandomValues.bind(msCrypto),o=new Uint8Array(16)},{}],105:[function(e,t,n){"use strict";function r(e,t,n,r){switch(e){case 0:return t&n^~t&r;case 1:case 3:return t^n^r;case 2:return t&n^t&r^n&r}}function o(e,t){return e<<t|e>>>32-t}Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var i=function(e){var t=[1518500249,1859775393,2400959708,3395469782],n=[1732584193,4023233417,2562383102,271733878,3285377520];if("string"==typeof e){var i=unescape(encodeURIComponent(e));e=new Array(i.length);for(var a=0;a<i.length;a++)e[a]=i.charCodeAt(a)}e.push(128);var s=e.length/4+2,c=Math.ceil(s/16),u=new Array(c);for(a=0;a<c;a++){u[a]=new Array(16);for(var l=0;l<16;l++)u[a][l]=e[64*a+4*l]<<24|e[64*a+4*l+1]<<16|e[64*a+4*l+2]<<8|e[64*a+4*l+3]}for(u[c-1][14]=8*(e.length-1)/Math.pow(2,32),u[c-1][14]=Math.floor(u[c-1][14]),u[c-1][15]=8*(e.length-1)&4294967295,a=0;a<c;a++){for(var p=new Array(80),d=0;d<16;d++)p[d]=u[a][d];for(d=16;d<80;d++)p[d]=o(p[d-3]^p[d-8]^p[d-14]^p[d-16],1);var f=n[0],h=n[1],g=n[2],m=n[3],v=n[4];for(d=0;d<80;d++){var y=Math.floor(d/20),b=o(f,5)+r(y,h,g,m)+v+t[y]+p[d]>>>0;v=m,m=g,g=o(h,30)>>>0,h=f,f=b}n[0]=n[0]+f>>>0,n[1]=n[1]+h>>>0,n[2]=n[2]+g>>>0,n[3]=n[3]+m>>>0,n[4]=n[4]+v>>>0}return[n[0]>>24&255,n[0]>>16&255,n[0]>>8&255,255&n[0],n[1]>>24&255,n[1]>>16&255,n[1]>>8&255,255&n[1],n[2]>>24&255,n[2]>>16&255,n[2]>>8&255,255&n[2],n[3]>>24&255,n[3]>>16&255,n[3]>>8&255,255&n[3],n[4]>>24&255,n[4]>>16&255,n[4]>>8&255,255&n[4]]};n.default=i},{}],106:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var r,o,i=s(e("./rng.js")),a=s(e("./bytesToUuid.js"));function s(e){return e&&e.__esModule?e:{default:e}}var c=0,u=0,l=function(e,t,n){var s=t&&n||0,l=t||[],p=(e=e||{}).node||r,d=void 0!==e.clockseq?e.clockseq:o;if(null==p||null==d){var f=e.random||(e.rng||i.default)();null==p&&(p=r=[1|f[0],f[1],f[2],f[3],f[4],f[5]]),null==d&&(d=o=16383&(f[6]<<8|f[7]))}var h=void 0!==e.msecs?e.msecs:(new Date).getTime(),g=void 0!==e.nsecs?e.nsecs:u+1,m=h-c+(g-u)/1e4;if(m<0&&void 0===e.clockseq&&(d=d+1&16383),(m<0||h>c)&&void 0===e.nsecs&&(g=0),g>=1e4)throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");c=h,u=g,o=d;var v=(1e4*(268435455&(h+=122192928e5))+g)%4294967296;l[s++]=v>>>24&255,l[s++]=v>>>16&255,l[s++]=v>>>8&255,l[s++]=255&v;var y=h/4294967296*1e4&268435455;l[s++]=y>>>8&255,l[s++]=255&y,l[s++]=y>>>24&15|16,l[s++]=y>>>16&255,l[s++]=d>>>8|128,l[s++]=255&d;for(var b=0;b<6;++b)l[s+b]=p[b];return t||(0,a.default)(l)};n.default=l},{"./bytesToUuid.js":101,"./rng.js":104}],107:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var r=i(e("./v35.js")),o=i(e("./md5.js"));function i(e){return e&&e.__esModule?e:{default:e}}var a=(0,r.default)("v3",48,o.default);n.default=a},{"./md5.js":103,"./v35.js":108}],108:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=function(e,t,n){var r=function(e,r,i,a){var s=i&&a||0;if("string"==typeof e&&(e=function(e){e=unescape(encodeURIComponent(e));for(var t=new Array(e.length),n=0;n<e.length;n++)t[n]=e.charCodeAt(n);return t}(e)),"string"==typeof r&&(r=function(e){var t=[];return e.replace(/[a-fA-F0-9]{2}/g,(function(e){t.push(parseInt(e,16))})),t}(r)),!Array.isArray(e))throw TypeError("value must be an array of bytes");if(!Array.isArray(r)||16!==r.length)throw TypeError("namespace must be uuid string or an Array of 16 byte values");var c=n(r.concat(e));if(c[6]=15&c[6]|t,c[8]=63&c[8]|128,i)for(var u=0;u<16;++u)i[s+u]=c[u];return i||(0,o.default)(c)};try{r.name=e}catch(e){}return r.DNS=i,r.URL=a,r},n.URL=n.DNS=void 0;var r,o=(r=e("./bytesToUuid.js"))&&r.__esModule?r:{default:r},i="6ba7b810-9dad-11d1-80b4-00c04fd430c8";n.DNS=i;var a="6ba7b811-9dad-11d1-80b4-00c04fd430c8";n.URL=a},{"./bytesToUuid.js":101}],109:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var r=i(e("./rng.js")),o=i(e("./bytesToUuid.js"));function i(e){return e&&e.__esModule?e:{default:e}}var a=function(e,t,n){var i=t&&n||0;"string"==typeof e&&(t="binary"===e?new Array(16):null,e=null);var a=(e=e||{}).random||(e.rng||r.default)();if(a[6]=15&a[6]|64,a[8]=63&a[8]|128,t)for(var s=0;s<16;++s)t[i+s]=a[s];return t||(0,o.default)(a)};n.default=a},{"./bytesToUuid.js":101,"./rng.js":104}],110:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;var r=i(e("./v35.js")),o=i(e("./sha1.js"));function i(e){return e&&e.__esModule?e:{default:e}}var a=(0,r.default)("v5",80,o.default);n.default=a},{"./sha1.js":105,"./v35.js":108}],111:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0});var r=e("./utils/LRU"),o=function(){function e(e){void 0===e&&(e=1e3),this.maxSize=e,this.cache=new r.LRUCache(e)}return Object.defineProperty(e.prototype,"size",{get:function(){return this.cache.length},enumerable:!0,configurable:!0}),e.prototype.put=function(t,n){var r="string"!=typeof t?e.getKeyString(t):t,o=this.populateValue(n);this.cache.put(r,o)},e.prototype.get=function(t){var n="string"!=typeof t?e.getKeyString(t):t,r=Date.now(),o=this.cache.get(n);if(o){for(var i=o.length-1;i>=0;i--)o[i].Expire<r&&o.splice(i,1);if(0===o.length)return void this.cache.remove(n)}return o},e.getKeyString=function(e){for(var t=[],n=Object.keys(e).sort(),r=0;r<n.length;r++){var o=n[r];void 0!==e[o]&&t.push(e[o])}return t.join(" ")},e.prototype.populateValue=function(e){var t=Date.now();return e.map((function(e){return{Address:e.Address||"",Expire:t+60*(e.CachePeriodInMinutes||1)*1e3}}))},e.prototype.empty=function(){this.cache.empty()},e.prototype.remove=function(t){var n="string"!=typeof t?e.getKeyString(t):t;this.cache.remove(n)},e}();n.EndpointCache=o},{"./utils/LRU":112}],112:[function(e,t,n){"use strict";Object.defineProperty(n,"__esModule",{value:!0});var r=function(e,t){this.key=e,this.value=t},o=function(){function e(e){if(this.nodeMap={},this.size=0,"number"!=typeof e||e<1)throw new Error("Cache size can only be positive number");this.sizeLimit=e}return Object.defineProperty(e.prototype,"length",{get:function(){return this.size},enumerable:!0,configurable:!0}),e.prototype.prependToList=function(e){this.headerNode?(this.headerNode.prev=e,e.next=this.headerNode):this.tailNode=e,this.headerNode=e,this.size++},e.prototype.removeFromTail=function(){if(this.tailNode){var e=this.tailNode,t=e.prev;return t&&(t.next=void 0),e.prev=void 0,this.tailNode=t,this.size--,e}},e.prototype.detachFromList=function(e){this.headerNode===e&&(this.headerNode=e.next),this.tailNode===e&&(this.tailNode=e.prev),e.prev&&(e.prev.next=e.next),e.next&&(e.next.prev=e.prev),e.next=void 0,e.prev=void 0,this.size--},e.prototype.get=function(e){if(this.nodeMap[e]){var t=this.nodeMap[e];return this.detachFromList(t),this.prependToList(t),t.value}},e.prototype.remove=function(e){if(this.nodeMap[e]){var t=this.nodeMap[e];this.detachFromList(t),delete this.nodeMap[e]}},e.prototype.put=function(e,t){if(this.nodeMap[e])this.remove(e);else if(this.size===this.sizeLimit){var n=this.removeFromTail().key;delete this.nodeMap[n]}var o=new r(e,t);this.nodeMap[e]=o,this.prependToList(o)},e.prototype.empty=function(){for(var e=Object.keys(this.nodeMap),t=0;t<e.length;t++){var n=e[t],r=this.nodeMap[n];this.detachFromList(r),delete this.nodeMap[n]}},e}();n.LRUCache=o},{}],113:[function(e,t,n){e("./browser_loader");var r=e("./core");"undefined"!=typeof window&&(window.AWS=r),void 0!==t&&(t.exports=r),"undefined"!=typeof self&&(self.AWS=r),Object.prototype.hasOwnProperty.call(r,"Connect")||(r.apiLoader.services.connect={},r.Connect=r.Service.defineService("connect",["2017-02-15"])),r.apiLoader.services.connect["2017-02-15"]=e("../apis/connect-2017-02-15.min")},{"../apis/connect-2017-02-15.min":3,"./browser_loader":16,"./core":19}]},{},[113])},555:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(t,n,r){return(n=function(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}(n))in t?Object.defineProperty(t,n,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[n]=r,t}!function(){var t=this||globalThis,r=t.connect||{};t.connect=r,t.lily=r,r.ClientMethods=r.makeEnum(["getAgentSnapshot","putAgentState","getAgentStates","getDialableCountryCodes","getRoutingProfileQueues","getAgentPermissions","getAgentConfiguration","updateAgentConfiguration","acceptContact","createOutboundContact","createTaskContact","clearContact","completeContact","destroyContact","rejectContact","notifyContactIssue","updateContactAttributes","createAdditionalConnection","destroyConnection","holdConnection","resumeConnection","toggleActiveConnections","conferenceConnections","sendClientLogs","sendDigits","sendSoftphoneCallReport","sendSoftphoneCallMetrics","getEndpoints","getNewAuthToken","createTransport","muteParticipant","unmuteParticipant","updateMonitorParticipantState","pauseContact","resumeContact"]),r.AgentAppClientMethods={GET_CONTACT:"AgentAppService.Lcms.getContact",DELETE_SPEAKER:"AgentAppService.VoiceId.deleteSpeaker",ENROLL_BY_SESSION:"AgentAppService.VoiceId.enrollBySession",EVALUATE_SESSION:"AgentAppService.VoiceId.evaluateSession",DESCRIBE_SPEAKER:"AgentAppService.VoiceId.describeSpeaker",OPT_OUT_SPEAKER:"AgentAppService.VoiceId.optOutSpeaker",UPDATE_VOICE_ID_DATA:"AgentAppService.Lcms.updateVoiceIdData",DESCRIBE_SESSION:"AgentAppService.VoiceId.describeSession",UPDATE_SESSION:"AgentAppService.VoiceId.updateSession",START_VOICE_ID_SESSION:"AgentAppService.Nasa.startVoiceIdSession",LIST_INTEGRATION_ASSOCIATIONS:"AgentAppService.Acs.listIntegrationAssociations"},r.MasterMethods=r.makeEnum(["becomeMaster","checkMaster"]),r.TaskTemplatesClientMethods=r.makeEnum(["listTaskTemplates","getTaskTemplate","createTemplatedTask","updateContact"]),r.ApiProxyClientMethods={QR_INTEGRATION_EXISTS:"qrIntegrationExists",QR_SEARCH_QUICK_RESPONSES:"qrSearchQuickResponses",BATCH_GET_ATTACHED_FILE_METADATA:"batchGetAttachedFileMetadata",START_ATTACHED_FILE_UPLOAD:"startAttachedFileUpload",COMPLETE_ATTACHED_FILE_UPLOAD:"completeAttachedFileUpload",GET_ATTACHED_FILE:"getAttachedFile",DELETE_ATTACHED_FILE:"deleteAttachedFile",CREATE_OUTBOUND_EMAIL_CONTACT:"createOutboundEmailContact",START_OUTBOUND_EMAIL_CONTACT:"startOutboundEmailContact",LIST_CONTACT_REFERENCES:"listContactReferences",DESCRIBE_CONTACT:"describeContact",LIST_ASSOCIATED_CONTACTS:"listAssociatedContacts",START_SCREEN_SHARING:"startScreenSharing"},r.RetryableClientMethodsList=[r.ClientMethods.GET_AGENT_SNAPSHOT,r.ClientMethods.GET_AGENT_CONFIGURATION,r.ClientMethods.GET_AGENT_PERMISSIONS,r.ClientMethods.GET_AGENT_STATES,r.ClientMethods.GET_DIALABLE_COUNTRY_CODES,r.ClientMethods.GET_ROUTING_PROFILE_QUEUES],r.RetryableErrors=r.makeEnum(["unauthorized","accessDenied"]),r.RetryStatus=r.makeEnum(["retrying","exhausted","none"]);var o=function(){};o.EMPTY_CALLBACKS={success:function(){},failure:function(){}},o.prototype.call=function(e,t,n){r.assertNotNull(e,"method");var i=t||{},a=n||o.EMPTY_CALLBACKS;this._callImpl(e,i,a)},o.prototype._callImpl=function(e,t,n){throw new r.NotImplementedError};var i=function(){o.call(this)};(i.prototype=Object.create(o.prototype)).constructor=i,i.prototype._callImpl=function(e,t,n){if(n&&n.failure){var o=r.sprintf("No such method exists on NULL client: %s",e);n.failure(new r.ValueError(o),{message:o})}};var a=function(e,t,n){o.call(this),this.conduit=e,this.requestEvent=t,this.responseEvent=n,this._requestIdCallbacksMap={},this.conduit.onUpstream(n,r.hitch(this,this._handleResponse))};(a.prototype=Object.create(o.prototype)).constructor=a,a.prototype._callImpl=function(e,t,n){var o=r.EventFactory.createRequest(this.requestEvent,e,t);this._requestIdCallbacksMap[o.requestId]=n;var i=[r.ClientMethods.SEND_CLIENT_LOGS,r.ClientMethods.SEND_SOFTPHONE_CALL_METRICS,r.ClientMethods.SEND_SOFTPHONE_CALL_REPORT];try{o.event!==r.EventType.API_REQUEST||i.includes(o.method)||r.getLog().trace("Sending API_REQUEST event for ".concat(o.method," to upstream")).withObject({method:o.method,params:o.params,stack:(new Error).stack}).sendInternalLogToServer()}catch(e){r.getLog().error("Stack trace Log Failed").withObject({err:e}).sendInternalLogToServer()}this.conduit.sendUpstream(o.event,o)},a.prototype._getCallbacksForRequest=function(e){var t=this._requestIdCallbacksMap[e]||null;return null!=t&&delete this._requestIdCallbacksMap[e],t},a.prototype._handleResponse=function(e){var t=this._getCallbacksForRequest(e.requestId);null!=t&&(e.err&&t.failure?t.failure(e.err,e.data):t.success&&t.success(e.data))};var s=function(e){a.call(this,e,r.EventType.API_REQUEST,r.EventType.API_RESPONSE)};(s.prototype=Object.create(a.prototype)).constructor=s;var c=function(){o.call(this),r.core.getEventBus().subscribe(r.EventType.API_PROXY_RESPONSE,r.hitch(this,this._handleResponse)),this._requestIdCallbacksMap={}};(c.prototype=Object.create(o.prototype)).constructor=c,c.prototype._callImpl=function(e,t,n){var o=r.EventFactory.createRequest(r.EventType.API_PROXY_REQUEST,e,t);this._requestIdCallbacksMap[o.requestId]=n,r.core.getEventBus().trigger(r.EventType.API_PROXY_REQUEST,o)},c.prototype._getCallbacksForRequest=function(e){var t=this._requestIdCallbacksMap[e]||null;return null!=t&&delete this._requestIdCallbacksMap[e],t},c.prototype._handleResponse=function(e){var t=this._getCallbacksForRequest(e.requestId);null!=t&&(e.err&&t.failure?t.failure(e.err,e.data):t.success&&t.success(e.data))};var u=function(e){a.call(this,e,r.EventType.MASTER_REQUEST,r.EventType.MASTER_RESPONSE)};(u.prototype=Object.create(a.prototype)).constructor=u;var l=function(e,t,n){r.assertNotNull(e,"authCookieName"),r.assertNotNull(t,"authToken"),r.assertNotNull(n,"endpoint"),o.call(this),this.endpointUrl=r.getUrlWithProtocol(n),this.authToken=t,this.authCookieName=e};(l.prototype=Object.create(o.prototype)).constructor=l,l.prototype._callImpl=function(e,t,n){var o=this,i={};i[o.authCookieName]=o.authToken;var a={method:"post",body:JSON.stringify(t||{}),headers:{Accept:"application/json","Content-Type":"application/json","X-Amz-target":e,"X-Amz-Bearer":JSON.stringify(i)}};r.fetch(o.endpointUrl,a).then((function(e){n.success(e)})).catch((function(e){var t=e.body.getReader(),r="",o=new TextDecoder;t.read().then((function i(a){var s=a.done,c=a.value;if(s){var u=JSON.parse(r);return u.status=e.status,void n.failure(u)}return r+=o.decode(c),t.read().then(i)}))}))};var p=function(e,t,n){r.assertNotNull(e,"authToken"),r.assertNotNull(t,"region"),o.call(this),AWS.config.credentials=new AWS.Credentials({}),AWS.config.region=t,this.authToken=e;var i=r.getBaseUrl(),a=n||(i.includes(".awsapps.com")?i+"/connect/api":i+"/api"),s=new AWS.Endpoint(a);this.client=new AWS.Connect({endpoint:s}),this.unauthorizedFailCounter=0,this.accessDeniedFailCounter=0};(p.prototype=Object.create(o.prototype)).constructor=p,p.prototype._callImpl=function(e,t,n){var o=this,i=r.getLog();if(r.contains(this.client,e))t=this._translateParams(e,t),"pauseContact"!==e&&"resumeContact"!==e||delete t.authentication,t&&t.relatedContactId&&null!==t.relatedContactId&&t.previousContactId&&delete t.previousContactId,i.trace("AWSClient: --\x3e Calling operation '%s'",e).sendInternalLogToServer(),this.client[e](t).on("build",(function(e){e.httpRequest.headers["X-Amz-Bearer"]=o.authToken})).send((function(t,a){try{if(t)t.code===r.CTIExceptions.UNAUTHORIZED_EXCEPTION||401===t.statusCode?o._retryMethod(e,n,t,a,r.RetryableErrors.UNAUTHORIZED):t.code===r.CTIExceptions.ACCESS_DENIED_EXCEPTION||403===t.statusCode?o._retryMethod(e,n,t,a,r.RetryableErrors.ACCESS_DENIED):(o.unauthorizedFailCounter=0,o.accessDeniedFailCounter=0,n.failure(o._formatCallError(o._addStatusCodeToError(t)),a)),i.trace("AWSClient: <-- Operation '%s' failed: %s",e,JSON.stringify(t)).sendInternalLogToServer();else{var s={};i.trace("AWSClient: <-- Operation '%s' succeeded.",e).withObject(a).sendInternalLogToServer(),o.unauthorizedFailCounter=0,o.accessDeniedFailCounter=0,this.httpResponse&&this.httpResponse.hasOwnProperty("body")&&(s.contentLength=this.httpResponse.body.length),n.success(a,s)}}catch(t){r.getLog().error("Failed to handle AWS API request for method %s",e).withException(t).sendInternalLogToServer()}}));else{var a=r.sprintf("No such method exists on AWS client: %s",e);n.failure(new r.ValueError(a),{message:a})}},p.prototype._isRetryableMethod=function(e){return r.RetryableClientMethodsList.includes(e)},p.prototype._retryMethod=function(e,t,o,i,a){var s=this,c=r.getLog(),u=function(e){return s._formatCallError(s._addStatusCodeToError(e))},l={maxCount:r.core.MAX_UNAUTHORIZED_RETRY_COUNT,failCounter:s.unauthorizedFailCounter,increaseCounter:function(){return s.unauthorizedFailCounter+=1},resetCounter:function(){return s.unauthorizedFailCounter=0},errorMessage:"unauthorized",exhaustedRetries:s.unauthorizedFailCounter>=r.core.MAX_UNAUTHORIZED_RETRY_COUNT,retryCallback:function(e,n){return t.failure(u(e),n)},defaultCallback:function(e,n){return t.authFailure(u(e),n)}};switch(a){case r.RetryableErrors.UNAUTHORIZED:break;case r.RetryableErrors.ACCESS_DENIED:l=n(n({},l),{},{maxCount:r.core.MAX_ACCESS_DENIED_RETRY_COUNT,failCounter:s.accessDeniedFailCounter,increaseCounter:function(){return s.accessDeniedFailCounter+=1},resetCounter:function(){return s.accessDeniedFailCounter=0},errorMessage:"access denied",exhaustedRetries:s.accessDeniedFailCounter>=r.core.MAX_ACCESS_DENIED_RETRY_COUNT,defaultCallback:function(e,n){return t.accessDenied(u(e),n)}})}var p=n(n({},o),{},{retryStatus:r.RetryStatus.NONE});if(s._isRetryableMethod(e)){if(!l.exhaustedRetries)return c.trace("AWSClient: <-- Operation ".concat(e," failed with ").concat(l.errorMessage," error. Retrying call for a ").concat(l.failCounter+1," time")).sendInternalLogToServer(),l.increaseCounter(),p=n(n({},p),{},{retryStatus:r.RetryStatus.RETRYING}),void l.retryCallback(p,i);c.trace("AWSClient: <-- Operation ".concat(e," exhausted max ").concat(l.maxCount," number of retries for ").concat(l.errorMessage," error")).sendInternalLogToServer(),l.resetCounter(),p=n(n({},p),{},{retryStatus:r.RetryStatus.EXHAUSTED})}else c.trace("AWSClient: <-- Operation ".concat(e," failed: ").concat(JSON.stringify(o))).sendInternalLogToServer();l.defaultCallback(p,i)},p.prototype._formatCallError=function(t){var o=n({type:t.code,message:t.message,stack:[],retryStatus:t.retryStatus||r.RetryStatus.NONE},t.statusCode&&{statusCode:t.statusCode});if(t.stack)try{Array.isArray(t.stack)?o.stack=t.stack:"object"===e(t.stack)?o.stack=[JSON.stringify(t.stack)]:"string"==typeof t.stack&&(o.stack=t.stack.split("\n"))}finally{}return o},p.prototype._addStatusCodeToError=function(e){if(e.statusCode)return e;var t=n({},e);if(e.code)switch(t.code){case r.CTIExceptions.UNAUTHORIZED_EXCEPTION:t.statusCode=401;break;case r.CTIExceptions.ACCESS_DENIED_EXCEPTION:t.statusCode=403}else t.statusCode=400;return t},p.prototype._requiresAuthenticationParam=function(e){return e!==r.ClientMethods.COMPLETE_CONTACT&&e!==r.ClientMethods.CLEAR_CONTACT&&e!==r.ClientMethods.REJECT_CONTACT&&e!==r.ClientMethods.CREATE_TASK_CONTACT&&e!==r.ClientMethods.UPDATE_MONITOR_PARTICIPANT_STATE},p.prototype._translateParams=function(e,t){switch(e){case r.ClientMethods.UPDATE_AGENT_CONFIGURATION:t.configuration=this._translateAgentConfiguration(t.configuration);break;case r.ClientMethods.SEND_SOFTPHONE_CALL_METRICS:t.softphoneStreamStatistics=this._translateSoftphoneStreamStatistics(t.softphoneStreamStatistics);break;case r.ClientMethods.SEND_SOFTPHONE_CALL_REPORT:t.report=this._translateSoftphoneCallReport(t.report)}return this._requiresAuthenticationParam(e)&&(t.authentication={authToken:this.authToken}),t},p.prototype._translateAgentConfiguration=function(e){return{name:e.name,softphoneEnabled:e.softphoneEnabled,softphoneAutoAccept:e.softphoneAutoAccept,extension:e.extension,routingProfile:this._translateRoutingProfile(e.routingProfile),agentPreferences:e.agentPreferences}},p.prototype._translateRoutingProfile=function(e){return{name:e.name,routingProfileARN:e.routingProfileARN,defaultOutboundQueue:this._translateQueue(e.defaultOutboundQueue)}},p.prototype._translateQueue=function(e){return{queueARN:e.queueARN,name:e.name}},p.prototype._translateSoftphoneStreamStatistics=function(e){return e.forEach((function(e){"packetsCount"in e&&(e.packetCount=e.packetsCount,delete e.packetsCount)})),e},p.prototype._translateSoftphoneCallReport=function(e){return"handshakingTimeMillis"in e&&(e.handshakeTimeMillis=e.handshakingTimeMillis,delete e.handshakingTimeMillis),"preTalkingTimeMillis"in e&&(e.preTalkTimeMillis=e.preTalkingTimeMillis,delete e.preTalkingTimeMillis),"handshakingFailure"in e&&(e.handshakeFailure=e.handshakingFailure,delete e.handshakingFailure),"talkingTimeMillis"in e&&(e.talkTimeMillis=e.talkingTimeMillis,delete e.talkingTimeMillis),e.softphoneStreamStatistics=this._translateSoftphoneStreamStatistics(e.softphoneStreamStatistics),e};var d=function(e){if(r.assertNotNull(e,"endpoint"),o.call(this),e.includes("/task-templates"))this.endpointUrl=r.getUrlWithProtocol(e);else{var t=new AWS.Endpoint(e),n=e.includes(".awsapps.com")?"/connect":"";this.endpointUrl=r.getUrlWithProtocol("".concat(t.host).concat(n,"/task-templates/api/ccp"))}};(d.prototype=Object.create(o.prototype)).constructor=d,d.prototype._callImpl=function(e,t,n){t&&t.relatedContactId&&null!==t.relatedContactId&&t.previousContactId&&delete t.previousContactId,r.assertNotNull(e,"method"),r.assertNotNull(t,"params");var o={credentials:"include",method:"GET",headers:{Accept:"application/json","Content-Type":"application/json","x-csrf-token":"csrf"}},i=t.instanceId,a=this.endpointUrl,s=r.TaskTemplatesClientMethods;switch(e){case s.LIST_TASK_TEMPLATES:if(a+="/proxy/instance/".concat(i,"/task/template"),t.queryParams){var c=new URLSearchParams(t.queryParams).toString();c&&(a+="?".concat(c))}break;case s.GET_TASK_TEMPLATE:r.assertNotNull(t.templateParams,"params.templateParams");var u=r.assertNotNull(t.templateParams.id,"params.templateParams.id"),l=t.templateParams.version;a+="/proxy/instance/".concat(i,"/task/template/").concat(u),l&&(a+="?snapshotVersion=".concat(l));break;case s.CREATE_TEMPLATED_TASK:a+="/".concat(e),o.body=JSON.stringify(t),o.method="PUT";break;case s.UPDATE_CONTACT:a+="/".concat(e),o.body=JSON.stringify(t),o.method="POST"}r.fetch(a,o).then((function(e){n.success(e)})).catch((function(e){var t=e.body.getReader(),r="",o=new TextDecoder;t.read().then((function i(a){var s=a.done,c=a.value;if(s){var u=JSON.parse(r);return u.status=e.status,void n.failure(u)}return r+=o.decode(c),t.read().then(i)}))}))},r.ClientBase=o,r.NullClient=i,r.UpstreamConduitClient=s,r.ApiProxyClient=c,r.UpstreamConduitMasterClient=u,r.AWSClient=p,r.AgentAppClient=l,r.TaskTemplatesClient=d}()},399:(e,t,n)=>{function r(e){return r="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},r(e)}function o(){"use strict";o=function(){return t};var e,t={},n=Object.prototype,i=n.hasOwnProperty,a=Object.defineProperty||function(e,t,n){e[t]=n.value},s="function"==typeof Symbol?Symbol:{},c=s.iterator||"@@iterator",u=s.asyncIterator||"@@asyncIterator",l=s.toStringTag||"@@toStringTag";function p(e,t,n){return Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}),e[t]}try{p({},"")}catch(e){p=function(e,t,n){return e[t]=n}}function d(e,t,n,r){var o=t&&t.prototype instanceof b?t:b,i=Object.create(o.prototype),s=new N(r||[]);return a(i,"_invoke",{value:R(e,n,s)}),i}function f(e,t,n){try{return{type:"normal",arg:e.call(t,n)}}catch(e){return{type:"throw",arg:e}}}t.wrap=d;var h="suspendedStart",g="suspendedYield",m="executing",v="completed",y={};function b(){}function E(){}function S(){}var C={};p(C,c,(function(){return this}));var T=Object.getPrototypeOf,I=T&&T(T(P([])));I&&I!==n&&i.call(I,c)&&(C=I);var w=S.prototype=b.prototype=Object.create(C);function A(e){["next","throw","return"].forEach((function(t){p(e,t,(function(e){return this._invoke(t,e)}))}))}function _(e,t){function n(o,a,s,c){var u=f(e[o],e,a);if("throw"!==u.type){var l=u.arg,p=l.value;return p&&"object"==r(p)&&i.call(p,"__await")?t.resolve(p.__await).then((function(e){n("next",e,s,c)}),(function(e){n("throw",e,s,c)})):t.resolve(p).then((function(e){l.value=e,s(l)}),(function(e){return n("throw",e,s,c)}))}c(u.arg)}var o;a(this,"_invoke",{value:function(e,r){function i(){return new t((function(t,o){n(e,r,t,o)}))}return o=o?o.then(i,i):i()}})}function R(t,n,r){var o=h;return function(i,a){if(o===m)throw Error("Generator is already running");if(o===v){if("throw"===i)throw a;return{value:e,done:!0}}for(r.method=i,r.arg=a;;){var s=r.delegate;if(s){var c=O(s,r);if(c){if(c===y)continue;return c}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(o===h)throw o=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);o=m;var u=f(t,n,r);if("normal"===u.type){if(o=r.done?v:g,u.arg===y)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(o=v,r.method="throw",r.arg=u.arg)}}}function O(t,n){var r=n.method,o=t.iterator[r];if(o===e)return n.delegate=null,"throw"===r&&t.iterator.return&&(n.method="return",n.arg=e,O(t,n),"throw"===n.method)||"return"!==r&&(n.method="throw",n.arg=new TypeError("The iterator does not provide a '"+r+"' method")),y;var i=f(o,t.iterator,n.arg);if("throw"===i.type)return n.method="throw",n.arg=i.arg,n.delegate=null,y;var a=i.arg;return a?a.done?(n[t.resultName]=a.value,n.next=t.nextLoc,"return"!==n.method&&(n.method="next",n.arg=e),n.delegate=null,y):a:(n.method="throw",n.arg=new TypeError("iterator result is not an object"),n.delegate=null,y)}function L(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function k(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function N(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(L,this),this.reset(!0)}function P(t){if(t||""===t){var n=t[c];if(n)return n.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var o=-1,a=function n(){for(;++o<t.length;)if(i.call(t,o))return n.value=t[o],n.done=!1,n;return n.value=e,n.done=!0,n};return a.next=a}}throw new TypeError(r(t)+" is not iterable")}return E.prototype=S,a(w,"constructor",{value:S,configurable:!0}),a(S,"constructor",{value:E,configurable:!0}),E.displayName=p(S,l,"GeneratorFunction"),t.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===E||"GeneratorFunction"===(t.displayName||t.name))},t.mark=function(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,S):(e.__proto__=S,p(e,l,"GeneratorFunction")),e.prototype=Object.create(w),e},t.awrap=function(e){return{__await:e}},A(_.prototype),p(_.prototype,u,(function(){return this})),t.AsyncIterator=_,t.async=function(e,n,r,o,i){void 0===i&&(i=Promise);var a=new _(d(e,n,r,o),i);return t.isGeneratorFunction(n)?a:a.next().then((function(e){return e.done?e.value:a.next()}))},A(w),p(w,l,"Generator"),p(w,c,(function(){return this})),p(w,"toString",(function(){return"[object Generator]"})),t.keys=function(e){var t=Object(e),n=[];for(var r in t)n.push(r);return n.reverse(),function e(){for(;n.length;){var r=n.pop();if(r in t)return e.value=r,e.done=!1,e}return e.done=!0,e}},t.values=P,N.prototype={constructor:N,reset:function(t){if(this.prev=0,this.next=0,this.sent=this._sent=e,this.done=!1,this.delegate=null,this.method="next",this.arg=e,this.tryEntries.forEach(k),!t)for(var n in this)"t"===n.charAt(0)&&i.call(this,n)&&!isNaN(+n.slice(1))&&(this[n]=e)},stop:function(){this.done=!0;var e=this.tryEntries[0].completion;if("throw"===e.type)throw e.arg;return this.rval},dispatchException:function(t){if(this.done)throw t;var n=this;function r(r,o){return s.type="throw",s.arg=t,n.next=r,o&&(n.method="next",n.arg=e),!!o}for(var o=this.tryEntries.length-1;o>=0;--o){var a=this.tryEntries[o],s=a.completion;if("root"===a.tryLoc)return r("end");if(a.tryLoc<=this.prev){var c=i.call(a,"catchLoc"),u=i.call(a,"finallyLoc");if(c&&u){if(this.prev<a.catchLoc)return r(a.catchLoc,!0);if(this.prev<a.finallyLoc)return r(a.finallyLoc)}else if(c){if(this.prev<a.catchLoc)return r(a.catchLoc,!0)}else{if(!u)throw Error("try statement without catch or finally");if(this.prev<a.finallyLoc)return r(a.finallyLoc)}}}},abrupt:function(e,t){for(var n=this.tryEntries.length-1;n>=0;--n){var r=this.tryEntries[n];if(r.tryLoc<=this.prev&&i.call(r,"finallyLoc")&&this.prev<r.finallyLoc){var o=r;break}}o&&("break"===e||"continue"===e)&&o.tryLoc<=t&&t<=o.finallyLoc&&(o=null);var a=o?o.completion:{};return a.type=e,a.arg=t,o?(this.method="next",this.next=o.finallyLoc,y):this.complete(a)},complete:function(e,t){if("throw"===e.type)throw e.arg;return"break"===e.type||"continue"===e.type?this.next=e.arg:"return"===e.type?(this.rval=this.arg=e.arg,this.method="return",this.next="end"):"normal"===e.type&&t&&(this.next=t),y},finish:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.finallyLoc===e)return this.complete(n.completion,n.afterLoc),k(n),y}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.tryLoc===e){var r=n.completion;if("throw"===r.type){var o=r.arg;k(n)}return o}}throw Error("illegal catch attempt")},delegateYield:function(t,n,r){return this.delegate={iterator:P(t),resultName:n,nextLoc:r},"next"===this.method&&(this.arg=e),y}},t}function i(e,t,n,r,o,i,a){try{var s=e[i](a),c=s.value}catch(e){return void n(e)}s.done?t(c):Promise.resolve(c).then(r,o)}function a(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function s(e){for(var t=1;t<arguments.length;t++){var n=null!=arguments[t]?arguments[t]:{};t%2?a(Object(n),!0).forEach((function(t){c(e,t,n[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):a(Object(n)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))}))}return e}function c(e,t,n){return(t=b(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function u(e,t){var n="undefined"!=typeof Symbol&&e[Symbol.iterator]||e["@@iterator"];if(!n){if(Array.isArray(e)||(n=function(e,t){if(e){if("string"==typeof e)return l(e,t);var n={}.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?l(e,t):void 0}}(e))||t&&e&&"number"==typeof e.length){n&&(e=n);var r=0,o=function(){};return{s:o,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:o}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var i,a=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return a=e.done,e},e:function(e){s=!0,i=e},f:function(){try{a||null==n.return||n.return()}finally{if(s)throw i}}}}function l(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function p(e,t,n){return t=f(t),function(e,t){if(t&&("object"==r(t)||"function"==typeof t))return t;if(void 0!==t)throw new TypeError("Derived constructors may only return object or undefined");return function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e)}(e,d()?Reflect.construct(t,n||[],f(e).constructor):t.apply(e,n))}function d(){try{var e=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){})))}catch(e){}return(d=function(){return!!e})()}function f(e){return f=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(e){return e.__proto__||Object.getPrototypeOf(e)},f(e)}function h(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),Object.defineProperty(e,"prototype",{writable:!1}),t&&g(e,t)}function g(e,t){return g=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(e,t){return e.__proto__=t,e},g(e,t)}function m(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function v(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,b(r.key),r)}}function y(e,t,n){return t&&v(e.prototype,t),n&&v(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function b(e){var t=function(e,t){if("object"!=r(e)||!e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var o=n.call(e,t||"default");if("object"!=r(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===t?String:Number)(e)}(e,"string");return"symbol"==r(t)?t:t+""}!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t,t.core={},t.globalResiliency=t.globalResiliency||{},t.core.initialized=!1,t.version="2.17.0",t.outerContextStreamsVersion=null,t.DEFAULT_BATCH_SIZE=500;var r="Amazon Connect CCP",a="https://{alias}.awsapps.com/auth/?client_id={client_id}&redirect_uri={redirect}",c="06919f4fd8ed324e",l="/auth/authorize",d="/connect/auth/authorize",f="IframeRefreshAttempts",g="IframeRefreshAttemptsDr",v="IframeInitializationSuccess",b="IframeInitializationSuccessDr",E="customviews",S=["ended","missed","error","rejected","acw"];t.numberOfConnectedCCPs=0,t.numberOfConnectedCCPsInThisTab=0,t.core.MAX_AUTHORIZE_RETRY_COUNT_FOR_SESSION=3,t.core.MAX_CTI_AUTH_RETRY_COUNT=10,t.core.ctiAuthRetryCount=0,t.core.authorizeTimeoutId=null,t.core.ctiTimeoutId=null,t.core.MAX_UNAUTHORIZED_RETRY_COUNT=20,t.core.MAX_ACCESS_DENIED_RETRY_COUNT=10,t.SessionStorageKeys=t.makeEnum(["tab_id","authorize_retry_count"]);var C=function(){return y((function t(n){m(this,t),this.key="".concat(n,"ParamsStorage::").concat(e.location.origin)}),[{key:"get",value:function(){try{var n=e.localStorage.getItem(this.key);return n&&JSON.parse(n)}catch(e){t.getLog().error("".concat(this.key,":: Failed to get softphone params from local storage!")).withException(e).sendInternalLogToServer()}return null}},{key:"set",value:function(n){try{n&&e.localStorage.setItem(this.key,JSON.stringify(n))}catch(e){t.getLog().error("".concat(this.key,":: Failed to set softphone params to local storage!")).withException(e).sendInternalLogToServer()}}},{key:"clean",value:function(){e.localStorage.removeItem(this.key)}}])}(),T=new(function(e){function t(){return m(this,t),p(this,t,["Softphone"])}return h(t,e),y(t)}(C)),I=new(function(e){function t(){return m(this,t),p(this,t,["Ringtone"])}return h(t,e),y(t)}(C));function w(e){var t=e.match(/^(?:https?:\/\/)?(?:[^@\n]+@)?(?:www\.)?([^:\/\n?]+)/gi);return t.length?t[0]:""}new(function(e){function t(){return m(this,t),p(this,t,["GlobalResiliency"])}return h(t,e),y(t)}(C)),t.core.checkNotInitialized=function(){t.core.initialized&&t.getLog().warn("Connect core already initialized, only needs to be initialized once.").sendInternalLogToServer()};var A=function(e,n){var r=e.getAgentStates().find((function(e){return e.type===t.AgentStateType.OFFLINE}));e.setState(r,n)},_=function(e){t.getLog().info("[Disaster Recovery] Signal sharedworker to set contacts suppressor to %s for instance %s.",e,t.core.region).sendInternalLogToServer(),t.core.getUpstream().sendUpstream(t.DisasterRecoveryEvents.SUPPRESS,{suppress:e,shouldSendFailoverDownstream:!1})},R=function(e,n){t.getLog().info("[DISASTER RECOVERY] Signal sharedworker to set forceOffline to %s for instance %s.",e,t.core.region).sendInternalLogToServer(),t.core.getUpstream().sendUpstream(t.DisasterRecoveryEvents.FORCE_OFFLINE,{offline:e,nextActiveArn:n})},O=function(e,n){var r=t.getLog(),o=t.agent.initialized?t.core.getAgentDataProvider().getInstanceId():t.core.region;r.info("[Disaster Recovery] Attempting to force instance ".concat(o," offline using ").concat(e?"soft":"hard"," failover")).sendInternalLogToServer(),t.agent((function(o){var i=0,a=o.getContacts(),s=!1;if(a.length){var c,l=u(a);try{for(l.s();!(c=l.n()).done;){var p=c.value;if(s)break;!e||p.getType()!==t.ContactType.QUEUE_CALLBACK&&p.getType()!==t.ContactType.VOICE?p.getAgentConnection().destroy({success:function(){++i===a.length&&(R(!1,n),A(o),r.info("[Disaster Recovery] Instance %s is now offline",t.core.region).sendInternalLogToServer())},failure:function(e){r.warn("[Disaster Recovery] An error occured while attempting to force this instance to offline in region %s",t.core.region).sendInternalLogToServer(),r.warn(e).sendInternalLogToServer(),R(!0,n),s=!0}}):(r.info("[Disaster Recovery] Will wait to complete failover of instance %s until voice contact with ID %s is destroyed",t.core.region,p.getContactId()).sendInternalLogToServer(),t.core.getUpstream().sendDownstream(t.DisasterRecoveryEvents.FAILOVER_PENDING,{nextActiveArn:n}),p.onDestroy((function(e){r.info("[Disaster Recovery] Voice contact with ID %s destroyed, continuing with failover in instance %s",e.getContactId(),t.core.region),O(!0,n)})))}}catch(e){l.e(e)}finally{l.f()}}else R(!1,n),A(o),r.info("[Disaster Recovery] Instance %s is now offline",t.core.region).sendInternalLogToServer()}))};t.core.terminateCustomView=function(e){var n,r,o=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"",i=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},a=i.resolveIframe,s=void 0===a||a,c=i.timeout,u=void 0===c?5e3:c,l=i.hideIframe,p=void 0===l||l,d=function(e,t,n){return(null==t?void 0:t.querySelector(n))||document.getElementById(e)||window.top.document.getElementById(e)};r=o?"".concat(E).concat(o):"".concat(E);var f=null===(n=t.agentApp.AppRegistry.get(r))||void 0===n?void 0:n.containerDOM,h="iframe[id='".concat(r,"']"),g=d(r,f,h);if(g)try{g.contentWindow.postMessage({topic:"lifecycle.terminated"},e),s&&(p&&(g.style.display="none"),console.info("[CustomViews] customviews iframe hidden for resolution during termination"),setTimeout((function(){t.agentApp.stopApp(r),d(r,f,h)?console.warn("[CustomViews] customviews application did not stop successfully in terminateCustomView operation"):console.info("[CustomViews] customviews application successfully stopped")}),u))}catch(e){throw new Error("[CustomViews] Error in terminateCustomView: ",e)}else console.warn("[CustomViews] terminateCustomView operation failed due to iframe not found")},t.core.initDisasterRecovery=function(e,n,r){var o=t.getLog();t.core.region=e.region,t.core.suppressContacts=n||_,t.core.forceOffline=r||O,t.core.getUpstream().onDownstream(t.DisasterRecoveryEvents.SET_OFFLINE,(function(e){t.ifMaster(t.MasterTopics.FAILOVER,(function(){t.core.forceOffline(e&&e.softFailover)}))})),t.core.getUpstream().onUpstream(t.DisasterRecoveryEvents.FORCE_OFFLINE,(function(e){t.ifMaster(t.MasterTopics.FAILOVER,(function(){t.core.forceOffline(e&&e.softFailover,e&&e.nextActiveArn)}))})),t.ifMaster(t.MasterTopics.FAILOVER,(function(){o.info("[Disaster Recovery] Initializing region %s as part of a Disaster Recovery fleet",t.core.region).sendInternalLogToServer()}),(function(){o.info("[Disaster Recovery] %s already part of a Disaster Recovery fleet",t.core.region).sendInternalLogToServer()})),e.pollForFailover&&t.DisasterRecoveryEvents.INIT_DR_POLLING?t.core.getUpstream().sendUpstream(t.DisasterRecoveryEvents.INIT_DR_POLLING,{instanceArn:e.instanceArn,otherArn:e.otherArn,authToken:e.authToken}):e.isPrimary?(t.core.suppressContacts(!1),o.info("[Disaster Recovery] %s instance is set to primary",t.core.region).sendInternalLogToServer()):(t.core.suppressContacts(!0),t.core.forceOffline(),o.info("[Disaster Recovery] %s instance is set to stand-by",t.core.region).sendInternalLogToServer())},t.core.init=function(e){t.core.eventBus=new t.EventBus,t.core.agentDataProvider=new D(t.core.getEventBus()),t.core.initClient(e),t.core.initAgentAppClient(e),t.core.initTaskTemplatesClient(e),t.core.initialized=!0},t.core.initClient=function(e){t.assertNotNull(e,"params");var n=t.assertNotNull(e.authToken,"params.authToken"),r=t.assertNotNull(e.region,"params.region"),o=e.endpoint||null;t.core.client=new t.AWSClient(n,r,o)},t.core.initAgentAppClient=function(e){t.assertNotNull(e,"params");var n=t.assertNotNull(e.authToken,"params.authToken"),r=t.assertNotNull(e.authCookieName,"params.authCookieName"),o=t.assertNotNull(e.agentAppEndpoint,"params.agentAppEndpoint");t.core.agentAppClient=new t.AgentAppClient(r,n,o)},t.core.initTaskTemplatesClient=function(e){t.assertNotNull(e,"params");var n=e.taskTemplatesEndpoint||e.endpoint;t.assertNotNull(n,"taskTemplatesEndpoint"),t.core.taskTemplatesClient=new t.TaskTemplatesClient(n)},t.core.terminate=function(){t.core.client=new t.NullClient,t.core.apiProxyClient=new t.NullClient,t.core.agentAppClient=new t.NullClient,t.core.taskTemplatesClient=new t.NullClient,t.core.masterClient=new t.NullClient;var e=t.core.getEventBus();e&&e.unsubscribeAll(),t.core.bus=new t.EventBus,t.core.agentDataProvider=null,t.core.softphoneManager=null,t.core.upstream=null,t.core.keepaliveManager=null,t.storageAccess.resetStorageAccessState(),t.agent.initialized=!1,t.core.initialized=!1},t.core.softphoneUserMediaStream=null,t.core.setSoftphoneUserMediaStream=function(e){t.core.softphoneUserMediaStream=e},t.core.initRingtoneEngines=function(n,r){t.getLog().info("[Ringtone Engine] initRingtoneEngine started").withObject({params:n}).sendInternalLogToServer(),t.assertNotNull(n,"params");var o=r||k,i=function(e){t.assertNotNull(e,"ringtoneSettings"),t.assertNotNull(e.voice,"ringtoneSettings.voice"),t.assertTrue(e.voice.ringtoneUrl||e.voice.disabled,"ringtoneSettings.voice.ringtoneUrl must be provided or ringtoneSettings.voice.disabled must be true"),t.assertNotNull(e.queue_callback,"ringtoneSettings.queue_callback"),t.assertTrue(e.queue_callback.ringtoneUrl||e.queue_callback.disabled,"ringtoneSettings.voice.ringtoneUrl must be provided or ringtoneSettings.queue_callback.disabled must be true"),t.core.ringtoneEngines={},t.agent((function(n){n.onRefresh((function(){t.ifMaster(t.MasterTopics.RINGTONE,(function(){var n=!1;e.voice.disabled||t.core.ringtoneEngines.voice||(t.core.ringtoneEngines.voice=new t.VoiceRingtoneEngine(e.voice),n=!0,t.getLog().info("VoiceRingtoneEngine initialized.").sendInternalLogToServer()),e.chat.disabled||t.core.ringtoneEngines.chat||(t.core.ringtoneEngines.chat=new t.ChatRingtoneEngine(e.chat),n=!0,t.getLog().info("ChatRingtoneEngine initialized.").sendInternalLogToServer()),e.task.disabled||t.core.ringtoneEngines.task||(t.core.ringtoneEngines.task=new t.TaskRingtoneEngine(e.task),n=!0,t.getLog().info("TaskRingtoneEngine initialized.").sendInternalLogToServer()),e.email.disabled||t.core.ringtoneEngines.email||(t.core.ringtoneEngines.email=new t.EmailRingtoneEngine(e.email),n=!0,t.getLog().info("EmailRingtoneEngine initialized.").sendInternalLogToServer()),e.queue_callback.disabled||t.core.ringtoneEngines.queue_callback||(t.core.ringtoneEngines.queue_callback=new t.QueueCallbackRingtoneEngine(e.queue_callback),n=!0,t.getLog().info("QueueCallbackRingtoneEngine initialized.").sendInternalLogToServer()),n&&t.core._ringerDeviceId&&o({deviceId:t.core._ringerDeviceId})}))}))})),L()},a=function(e,n){e.ringtone=e.ringtone||{},e.ringtone.voice=e.ringtone.voice||{},e.ringtone.queue_callback=e.ringtone.queue_callback||{},e.ringtone.chat=e.ringtone.chat||{disabled:!0},e.ringtone.task=e.ringtone.task||{disabled:!0},e.ringtone.email=e.ringtone.email||{disabled:!0},n.softphone&&(n.softphone.disableRingtone&&(e.ringtone.voice.disabled=!0,e.ringtone.queue_callback.disabled=!0),n.softphone.ringtoneUrl&&(e.ringtone.voice.ringtoneUrl=n.softphone.ringtoneUrl,e.ringtone.queue_callback.ringtoneUrl=n.softphone.ringtoneUrl)),n.chat&&(n.chat.disableRingtone&&(e.ringtone.chat.disabled=!0),n.chat.ringtoneUrl&&(e.ringtone.chat.ringtoneUrl=n.chat.ringtoneUrl)),n.task&&(n.task.disableRingtone&&(e.ringtone.task.disabled=!0),n.task.ringtoneUrl&&(e.ringtone.task.ringtoneUrl=n.task.ringtoneUrl)),n.email&&(n.email.disableRingtone&&(e.ringtone.email.disabled=!0),n.email.ringtoneUrl&&(e.ringtone.email.ringtoneUrl=n.email.ringtoneUrl)),n.ringtone&&(e.ringtone.voice=t.merge(e.ringtone.voice,n.ringtone.voice||{}),e.ringtone.queue_callback=t.merge(e.ringtone.queue_callback,n.ringtone.voice||{}),e.ringtone.chat=t.merge(e.ringtone.chat,n.ringtone.chat||{}),e.ringtone.task=t.merge(e.ringtone.task,n.ringtone.task||{}),e.ringtone.email=t.merge(e.ringtone.email,n.ringtone.email||{}))};if(a(n,n),t.isFramed()){var s;t.core.getEventBus().subscribe(t.EventType.CONFIGURE,(function(r){e.clearTimeout(s),t.getLog().info("[Ringtone Engine] Configure event handler executed").sendInternalLogToServer(),this.unsubscribe(),a(n,r),I.set(n.ringtone),i(n.ringtone)}));var c=I.get();c&&t.core.getUpstream().onUpstream(t.EventType.ACKNOWLEDGE,(function(n){n&&n.id&&(t.getLog().info("[RingtoneEngine] Embedded CCP is refreshed successfully and waiting for configure Message handler to execute").sendInternalLogToServer(),this.unsubscribe(),s=e.setTimeout((function(){t.getLog().info("[RingtoneEngine] Embedded CCP is refreshed without configure message & Initializing setupRingtoneEngines (Ringtone Engine) from localStorage ringtone params. ").withObject({ringtone:c}).sendInternalLogToServer(),i(c)}),100))}))}else i(n.ringtone)};var L=function(){t.core.getEventBus().subscribe(t.ConfigurationEvents.SET_RINGER_DEVICE,k)},k=function(){var e=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}).deviceId||"";if(t.getLog().info("[Audio Device Settings] Attempting to set ringer device ".concat(e)).sendInternalLogToServer(),0===t.keys(t.core.ringtoneEngines).length)return t.getLog().info("[Audio Device Settings] setRingerDevice called before ringtone engine is initialized").sendInternalLogToServer(),void(e&&(t.core._ringerDeviceId=e,t.getLog().warn("[Audio Device Settings] stored device Id for later use, once ringtone engine is up.").sendInternalLogToServer(),t.publishMetric({name:"SetRingerDeviceBeforeInitRingtoneEngine",data:{count:1}})));if(e){var n=function(n){t.core.ringtoneEngines[n].setOutputDevice(e).then((function(e){t.getLog().info("[Audio Device Settings] ringtoneType ".concat(n," successfully set to deviceid ").concat(e)).sendInternalLogToServer()})).catch((function(e){t.getLog().error(e)}))};for(var r in t.core.ringtoneEngines)n(r);t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.RINGER_DEVICE_CHANGED,data:{deviceId:e}})}else t.getLog().warn("[Audio Device Settings] Setting ringer device cancelled due to missing deviceId").sendInternalLogToServer()};t.core.initSoftphoneManager=function(n){var r=n||{};t.getLog().info("[Softphone Manager] initSoftphoneManager started").sendInternalLogToServer();var o=function(e){var n=t.merge(r.softphone||{},e);t.getLog().info("[Softphone Manager] competeForMasterOnAgentUpdate executed").withObject({softphoneParams:n}).sendInternalLogToServer(),t.agent((function(e){e.getChannelConcurrency(t.ChannelType.VOICE)&&e.onRefresh((function(){var r=this;t.getLog().info("[Softphone Manager] agent refresh handler executed").sendInternalLogToServer(),t.ifMaster(t.MasterTopics.SOFTPHONE,(function(){t.getLog().info("[Softphone Manager] confirmed as softphone master topic").sendInternalLogToServer(),!t.core.softphoneManager&&e.isSoftphoneEnabled()&&(t.core.softphoneManager=new t.SoftphoneManager(n),r.unsubscribe())}))}))}))};if(t.isFramed()&&t.isCCP()){var i;t.core.getEventBus().subscribe(t.EventType.CONFIGURE,(function(n){e.clearTimeout(i),t.getLog().info("[Softphone Manager] Configure event handler executed").withObject({data:n}).sendInternalLogToServer(),T.set(n.softphone),n.softphone&&n.softphone.allowFramedSoftphone&&(this.unsubscribe(),o(n.softphone)),s(n.softphone)}));var a=T.get();a&&t.core.getUpstream().onUpstream(t.EventType.ACKNOWLEDGE,(function(n){n&&n.id&&(t.getLog().info("[Softphone Manager] Embedded CCP is refreshed successfully and waiting for configure Message handler to execute").sendInternalLogToServer(),this.unsubscribe(),i=e.setTimeout((function(){t.getLog().info("[Softphone Manager] Embedded CCP is refreshed without configure message handler execution").withObject({softphoneParamsFromLocalStorage:a}).sendInternalLogToServer(),t.publishMetric({name:"EmbeddedCCPRefreshedWithoutInitCCP",data:{count:1}}),s(a),a.allowFramedSoftphone&&(t.getLog().info("[Softphone Manager] Embedded CCP is refreshed & Initializing competeForMasterOnAgentUpdate (Softphone manager) from localStorage softphone params").sendInternalLogToServer(),o(a))}),100))}))}else o(r),s(r);function s(e){var n=t.merge(r.softphone||{},e);t.core.softphoneParams=n,t.isFirefoxBrowser()&&(t.core.getUpstream().onUpstream(t.EventType.MASTER_RESPONSE,(function(e){e.data&&e.data.topic===t.MasterTopics.SOFTPHONE&&e.data.takeOver&&e.data.masterId!==t.core.portStreamId&&t.core.softphoneManager&&(t.core.softphoneManager.onInitContactSub.unsubscribe(),delete t.core.softphoneManager)})),t.core.getEventBus().subscribe(t.ConnectionEvents.READY_TO_START_SESSION,(function(){t.ifMaster(t.MasterTopics.SOFTPHONE,(function(){t.core.softphoneManager&&t.core.softphoneManager.startSession()}),(function(){t.becomeMaster(t.MasterTopics.SOFTPHONE,(function(){t.agent((function(e){!t.core.softphoneManager&&e.isSoftphoneEnabled()&&(t.becomeMaster(t.MasterTopics.SEND_LOGS),t.core.softphoneManager=new t.SoftphoneManager(n),t.core.softphoneManager.startSession())}))}))}))})),t.contact((function(e){t.agent((function(n){e.onRefresh((function(e){if(t.hasOtherConnectedCCPs()&&"visible"===document.visibilityState&&(e.getStatus().type===t.ContactStatusType.CONNECTING||e.getStatus().type===t.ContactStatusType.INCOMING)){var r=e.isSoftphoneCall()&&!e.isInbound(),o=e.isSoftphoneCall()&&n.getConfiguration().softphoneAutoAccept,i=e.getType()===t.ContactType.QUEUE_CALLBACK;(r||o||i)&&t.core.triggerReadyToStartSessionEvent()}}))}))})))}t.agent((function(e){e.isSoftphoneEnabled()&&e.getChannelConcurrency(t.ChannelType.VOICE)&&t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.EventType.MUTE})}))},t.core.triggerReadyToStartSessionEvent=function(){var e=t.core.softphoneParams&&t.core.softphoneParams.allowFramedSoftphone;t.isCCP()?e?t.core.getEventBus().trigger(t.ConnectionEvents.READY_TO_START_SESSION):t.isFramed()?t.core.getUpstream().sendDownstream(t.ConnectionEvents.READY_TO_START_SESSION):t.core.getEventBus().trigger(t.ConnectionEvents.READY_TO_START_SESSION):e?t.core.getUpstream().sendUpstream(t.ConnectionEvents.READY_TO_START_SESSION):t.core.getEventBus().trigger(t.ConnectionEvents.READY_TO_START_SESSION)},t.core.initPageOptions=function(e){if(t.assertNotNull(e,"params"),t.isFramed()){var n=t.core.getEventBus();n.subscribe(t.EventType.CONFIGURE,(function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ConfigurationEvents.CONFIGURE,data:e})})),n.subscribe(t.EventType.MEDIA_DEVICE_REQUEST,(function(){function e(e){t.core.getUpstream().sendDownstream(t.EventType.MEDIA_DEVICE_RESPONSE,e)}navigator&&navigator.mediaDevices?navigator.mediaDevices.enumerateDevices().then((function(t){devices=t||[],devices=devices.map((function(e){return e.toJSON()})),e(devices)})).catch((function(t){e({error:t.message})})):e({error:"No navigator or navigator.mediaDevices object found"})}))}},t.core.initApiProxyService=function(){t.core.apiProxyClient=new t.ApiProxyClient,t.isFramed()&&(t.core.handleApiProxyRequest=function(e){null!=e&&e.method&&t.core.getApiProxyClient().call(e.method,e.params,{success:function(n){var r={data:n,requestId:e.requestId};t.core.getUpstream().sendDownstream(t.EventType.API_RESPONSE,r)},failure:function(n){var r={err:n,requestId:e.requestId};t.core.getUpstream().sendDownstream(t.EventType.API_RESPONSE,r)}})})},t.core.getFrameMediaDevices=function(e){var n=null,r=e||1e3,o=new Promise((function(e,t){setTimeout((function(){t(new Error("Timeout exceeded"))}),r)})),i=new Promise((function(e,r){if(t.isCCP())navigator&&navigator.mediaDevices?navigator.mediaDevices.enumerateDevices().then((function(t){devices=t||[],devices=devices.map((function(e){return e.toJSON()})),e(devices)})):r(new Error("No navigator or navigator.mediaDevices object found"));else{var o=t.core.getEventBus();n=o.subscribe(t.EventType.MEDIA_DEVICE_RESPONSE,(function(t){t.error?r(new Error(t.error)):e(t)})),t.core.getUpstream().sendUpstream(t.EventType.MEDIA_DEVICE_REQUEST)}}));return Promise.race([i,o]).finally((function(){n&&n.unsubscribe()}))},t.core.authorize=function(e){var n=e;return n||(n=t.core.isLegacyDomain()?d:l),t.fetch(n,{credentials:"include"},2e3,5)},t.core.verifyDomainAccess=function(e,n){if(t.getLog().warn("This API will be deprecated in the next major version release"),!t.isFramed())return Promise.resolve();var r={headers:{"X-Amz-Bearer":e}},o=null;return o=n||(t.core.isLegacyDomain()?"/connect/whitelisted-origins":"/whitelisted-origins"),t.fetch(o,r,2e3,5).then((function(e){var t=w(window.document.referrer);return e.whitelistedOrigins.some((function(e){return t===w(e)}))?Promise.resolve():Promise.reject()}))},t.core.isLegacyDomain=function(e){return(e=e||window.location.href).includes(".awsapps.com")},t.core.initSharedWorker=function(n){if(t.core.checkNotInitialized(),!t.core.initialized){t.assertNotNull(n,"params");var r=t.assertNotNull(n.sharedWorkerUrl,"params.sharedWorkerUrl"),o=t.assertNotNull(n.authToken,"params.authToken"),i=t.assertNotNull(n.refreshToken,"params.refreshToken"),a=t.assertNotNull(n.authTokenExpiration,"params.authTokenExpiration"),s=t.assertNotNull(n.region,"params.region"),c=n.endpoint||null,u=n.authorizeEndpoint;u||(u=t.core.isLegacyDomain()?d:l);var p=n.agentAppEndpoint||null,f=n.taskTemplatesEndpoint||null,h=n.authCookieName||null;try{t.core.eventBus=new t.EventBus({logEvents:!0}),t.core.agentDataProvider=new D(t.core.getEventBus()),t.core.mediaFactory=new t.MediaFactory(n);var g=new SharedWorker(r,"ConnectSharedWorker"),m=new t.Conduit("ConnectSharedWorkerConduit",new t.PortStream(g.port),new t.WindowIOStream(window,parent));t.core.upstream=m,t.core.webSocketProvider=new P,e.onunload=function(){m.sendUpstream(t.EventType.CLOSE),g.port.close()},t.getLog().scheduleUpstreamLogPush(m),t.getLog().scheduleDownstreamClientSideLogsPush(),m.onAllUpstream(t.core.getEventBus().bridge()),m.onAllUpstream(m.passDownstream()),t.isFramed()&&(m.onAllDownstream(t.core.getEventBus().bridge()),m.onAllDownstream((function(e,n){n===t.EventType.API_REQUEST&&t.containsValue(t.ApiProxyClientMethods,null==e?void 0:e.method)?t.core.handleApiProxyRequest(e):m.passUpstream()(e,n)}))),m.sendUpstream(t.EventType.CONFIGURE,{authToken:o,authTokenExpiration:a,endpoint:c,refreshToken:i,region:s,authorizeEndpoint:u,agentAppEndpoint:p,taskTemplatesEndpoint:f,authCookieName:h,longPollingOptions:n.longPollingOptions||void 0}),m.onUpstream(t.EventType.ACKNOWLEDGE,(function(e){t.getLog().info("Acknowledged by the ConnectSharedWorker!").sendInternalLogToServer(),t.core.initialized=!0,t.core._setTabId(),t.core.portStreamId=e.id,this.unsubscribe()})),m.onUpstream(t.EventType.LOG,(function(e){e.loggerId!==t.getLog().getLoggerId()&&t.getLog().addLogEntry(t.LogEntry.fromObject(e))})),m.onUpstream(t.EventType.SERVER_BOUND_INTERNAL_LOG,(function(e){t.getLog().sendInternalLogEntryToServer(t.LogEntry.fromObject(e))})),m.onDownstream(t.EventType.SERVER_BOUND_INTERNAL_LOG,(function(e){t.isFramed()&&Array.isArray(e)&&e.forEach((function(e){t.getLog().sendInternalLogEntryToServer(t.LogEntry.fromObject(e))}))})),m.onDownstream(t.EventType.LOG,(function(e){t.isFramed()&&e.loggerId!==t.getLog().getLoggerId()&&t.getLog().addLogEntry(t.LogEntry.fromObject(e))})),t.core.onAuthFail(t.hitch(t.core,t.core._handleAuthFail,n.loginEndpoint||null,u)),t.core.onAuthorizeSuccess(t.hitch(t.core,t.core._handleAuthorizeSuccess)),t.getLog().info("User Agent: "+navigator.userAgent).sendInternalLogToServer(),t.getLog().info("isCCPv2: "+!0).sendInternalLogToServer(),t.getLog().info("isFramed: "+t.isFramed()).sendInternalLogToServer(),t.core.upstream.onDownstream(t.EventType.OUTER_CONTEXT_INFO,(function(e){var n=e.streamsVersion||null;t.getLog().info("StreamsJS Version: "+n).sendInternalLogToServer(),t.outerContextStreamsVersion=n})),m.onUpstream(t.EventType.UPDATE_CONNECTED_CCPS,(function(e){t.getLog().info("Number of connected CCPs updated: "+e.length).sendInternalLogToServer(),t.numberOfConnectedCCPs=e.length,e[t.core.tabId]&&!isNaN(e[t.core.tabId].length)&&t.numberOfConnectedCCPsInThisTab!==e[t.core.tabId].length&&(t.numberOfConnectedCCPsInThisTab=e[t.core.tabId].length,t.numberOfConnectedCCPsInThisTab>1&&t.getLog().warn("There are "+t.numberOfConnectedCCPsInThisTab+" connected CCPs in this tab. Please adjust your implementation to avoid complications. If you are embedding CCP, please do so exclusively with initCCP. InitCCP will not let you embed more than one CCP.").sendInternalLogToServer(),t.publishMetric({name:"ConnectedCCPSingleTabCount",data:{count:t.numberOfConnectedCCPsInThisTab}})),e.tabId&&e.streamsTabsAcrossBrowser&&t.ifMaster(t.MasterTopics.METRICS,(function(){return t.agent((function(){return t.publishMetric({name:"CCPTabsAcrossBrowserCount",data:{tabId:e.tabId,count:e.streamsTabsAcrossBrowser}})}))}))})),t.core.client=new t.UpstreamConduitClient(m),t.core.masterClient=new t.UpstreamConduitMasterClient(m),t.core.getEventBus().subscribe(t.EventType.TERMINATE,m.passUpstream()),t.core.getEventBus().subscribe(t.EventType.TERMINATED,(function(){window.location.reload(!0)})),g.port.start(),m.onUpstream(t.VoiceIdEvents.UPDATE_DOMAIN_ID,(function(e){e&&e.domainId&&(t.core.voiceIdDomainId=e.domainId)})),t.agent((function(){(new t.VoiceId).getDomainId().then((function(e){t.getLog().info("voiceId domainId successfully fetched at agent initialization: "+e).sendInternalLogToServer()})).catch((function(e){t.getLog().info("voiceId domainId not fetched at agent initialization").withObject({err:e}).sendInternalLogToServer()}))})),t.core.getNotificationManager().requestPermission(),m.onDownstream(t.DisasterRecoveryEvents.INIT_DISASTER_RECOVERY,(function(e){t.core.initDisasterRecovery(e)}))}catch(e){t.getLog().error("Failed to initialize the API shared worker, we're dead!").withException(e).sendInternalLogToServer()}}},t.core._setTabId=function(){try{t.core.tabId=window.sessionStorage.getItem(t.SessionStorageKeys.TAB_ID),t.core.tabId||(t.core.tabId=t.randomId(),window.sessionStorage.setItem(t.SessionStorageKeys.TAB_ID,t.core.tabId)),t.core.upstream.sendUpstream(t.EventType.TAB_ID,{tabId:t.core.tabId})}catch(e){t.getLog().error("[Tab Id] There was an issue setting the tab Id").withException(e).sendInternalLogToServer()}},t.core.initCCP=function(r,o){var i,u;if(t.core.checkNotInitialized(),!t.core.initialized){t.getLog().info("Iframe initialization started").sendInternalLogToServer();var l=Date.now();try{if(t.core._getCCPIframe())return void t.getLog().error("Attempted to call initCCP when an iframe generated by initCCP already exists").sendInternalLogToServer()}catch(e){t.getLog().error("Error while checking if initCCP has already been called").withException(e).sendInternalLogToServer()}var p={},d=void 0;if("string"==typeof o?p.ccpUrl=o:(p=o).provider&&(d=p.provider,delete p.provider),t.assertNotNull(r,"containerDiv"),t.assertNotNull(p.ccpUrl,"params.ccpUrl"),d)try{t.core._amazonConnectProviderData={provider:d,isStreamsProvider:!1},t.getLog().info("Using AmazonConnectProvider from params").withObject({providerId:t.core._amazonConnectProviderData.provider.id,providerType:t.core._amazonConnectProviderData.provider.constructor.name}).sendInternalLogToServer()}catch(e){t.getLog().error("Error when setting up AmazonConnectProvider from params").withException(e).sendInternalLogToServer()}else try{var h=n(781).AmazonConnectStreamsSite,m={instanceUrl:new URL(p.ccpUrl).origin};t.core._amazonConnectProviderData=s(s({},h.init(m)),{},{isStreamsProvider:!0}),t.getLog().info("Created AmazonConnectStreamsSite").withObject({providerId:t.core._amazonConnectProviderData.provider.id}).sendInternalLogToServer()}catch(e){t.getLog().error("Error when setting up AmazonConnectStreamsSite").withException(e).sendInternalLogToServer()}t.core.iframeStyle=p.style||"width: 100%; height: 100%;",null!==(i=p.softphone)&&void 0!==i&&i.disableStoringParamsInLocalStorage||(T.clean(),I.clean());var y,E,S,C,w=null;if(!0===(null===(u=p)||void 0===u?void 0:u.enableGlobalResiliency))if("string"!=typeof(null===(y=p)||void 0===y?void 0:y.secondaryCCPUrl)||""===(null===(E=p)||void 0===E?void 0:E.secondaryCCPUrl)){var A="enableGlobalResiliency flag was enabled, but secondaryCCPUrl was not provided. Global Resiliency will not be enabled";t.getLog().error(A).sendInternalLogToServer(),w={event:t.GlobalResiliencyEvents.CONFIGURE_ERROR,data:new Error(A)}}else{if("string"==typeof(null===(S=p)||void 0===S?void 0:S.loginUrl)&&""!==(null===(C=p)||void 0===C?void 0:C.loginUrl))return t.getLog().info("enableGlobalResiliency flag was enabled and secondaryCCPUrl and loginUrl was provided. Global Resiliency will be enabled").sendInternalLogToServer(),t.globalResiliency.initGRCCP(r,o);var R="enableGlobalResiliency flag was enabled, but loginUrl was not provided. Global Resiliency will not be enabled";t.getLog().error(R).sendInternalLogToServer(),w={event:t.GlobalResiliencyEvents.CONFIGURE_ERROR,data:new Error(R)}}t.storageAccess.init(p.ccpUrl,r,p.storageAccess||{});var O=t.core._createCCPIframe(r,p),L=new t.IFrameConduit(p.ccpUrl,window,O);t.core.upstream=L,t.core.eventBus=new t.EventBus({logEvents:!1}),t.storageAccess.canRequest()?t.storageAccess.setupRequestHandlers({onGrant:k}):k()}function k(){t.core.agentDataProvider=new D(t.core.getEventBus()),t.core.mediaFactory=new t.MediaFactory(p),t.core._sendIframeStyleDataUpstreamAfterReasonableWaitTime(O,L),t.core.webSocketProvider=new P,L.onAllUpstream(t.core.getEventBus().bridge()),t.core.keepaliveManager=new N(L,t.core.getEventBus(),p.ccpSynTimeout||1e3,p.ccpAckTimeout||3e3),t.core.iframeRefreshTimeout=null,t.core.ccpLoadTimeoutInstance=e.setTimeout((function(){t.core.ccpLoadTimeoutInstance=null,t.core.getEventBus().trigger(t.EventType.ACK_TIMEOUT),t.getLog().info("CCP LoadTimeout triggered").sendInternalLogToServer()}),p.ccpLoadTimeout||5e3),t.getLog().scheduleUpstreamOuterContextCCPLogsPush(L),t.getLog().scheduleUpstreamOuterContextCCPserverBoundLogsPush(L),L.onUpstream(t.EventType.ACKNOWLEDGE,(function(n){if(t.getLog().info("Acknowledged by the CCP!").sendInternalLogToServer(),t.core.client=new t.UpstreamConduitClient(L),t.core.masterClient=new t.UpstreamConduitMasterClient(L),t.core.portStreamId=n.id,(p.softphone||p.chat||p.task||p.pageOptions||p.shouldAddNamespaceToLogs||p.disasterRecoveryOn)&&L.sendUpstream(t.EventType.CONFIGURE,{softphone:p.softphone,chat:p.chat,task:p.task,pageOptions:p.pageOptions,shouldAddNamespaceToLogs:p.shouldAddNamespaceToLogs,disasterRecoveryOn:p.disasterRecoveryOn}),p.disasterRecoveryOn&&(t.core.region=p.region,t.core.suppressContacts=_,t.core.forceOffline=function(e){L.sendUpstream(t.DisasterRecoveryEvents.SET_OFFLINE,e)},L.sendUpstream(t.DisasterRecoveryEvents.INIT_DISASTER_RECOVERY,p)),t.core.ccpLoadTimeoutInstance&&(e.clearTimeout(t.core.ccpLoadTimeoutInstance),t.core.ccpLoadTimeoutInstance=null),L.sendUpstream(t.EventType.OUTER_CONTEXT_INFO,{streamsVersion:t.version}),t.core.keepaliveManager.start(),this.unsubscribe(),t.core.initialized=!0,t.core.getEventBus().trigger(t.EventType.INIT),w&&t.core.getEventBus().trigger(w.event,w.data),l){var r=Date.now()-l,o=t.core.iframeRefreshAttempt||0;t.getLog().info("Iframe initialization succeeded").sendInternalLogToServer(),t.getLog().info("Iframe initialization time ".concat(r)).sendInternalLogToServer(),t.getLog().info("Iframe refresh attempts ".concat(o)).sendInternalLogToServer(),setTimeout((function(){t.publishMetric({name:f,data:{count:o}}),t.publishMetric({name:v,data:{count:1}}),t.publishMetric({name:"IframeInitializationTime",data:{count:r}}),p.disasterRecoveryOn&&(t.publishMetric({name:g,data:{count:o}}),t.publishMetric({name:b,data:{count:1}}),t.publishMetric({name:"IframeInitializationTimeDr",data:{count:r}})),l=null}),1e3)}})),L.onUpstream(t.EventType.LOG,(function(e){e.loggerId!==t.getLog().getLoggerId()&&t.getLog().addLogEntry(t.LogEntry.fromObject(e))})),t.core.getEventBus().subscribe(t.EventType.ACK_TIMEOUT,(function(){if(!1!==p.loginPopup)try{var n=function(n){var r="https://lily.us-east-1.amazonaws.com/taw/auth/code";return t.assertNotNull(r),n.loginUrl?n.loginUrl:n.alias?(log.warn("The `alias` param is deprecated and should not be expected to function properly. Please use `ccpUrl` or `loginUrl`. See https://github.com/amazon-connect/amazon-connect-streams/blob/master/README.md#connectcoreinitccp for valid parameters."),a.replace("{alias}",n.alias).replace("{client_id}",c).replace("{redirect}",e.encodeURIComponent(r))):n.ccpUrl}(p);t.getLog().warn("ACK_TIMEOUT occurred, attempting to pop the login page if not already open.").sendInternalLogToServer(),t.core._openPopupWithLock(n,p.loginOptions)}catch(e){t.getLog().error("ACK_TIMEOUT occurred but we are unable to open the login popup.").withException(e).sendInternalLogToServer()}if(null==t.core.iframeRefreshTimeout)try{L.onUpstream(t.EventType.ACKNOWLEDGE,(function(){this.unsubscribe(),e.clearTimeout(t.core.iframeRefreshTimeout),t.core.iframeRefreshTimeout=null,(p.loginPopupAutoClose||p.loginOptions&&p.loginOptions.autoClose)&&t.core.loginWindow&&(t.core.loginWindow.close(),t.core.loginWindow=null)})),t.core._refreshIframeOnTimeout(p,r)}catch(e){t.getLog().error("Error occurred while refreshing iframe").withException(e).sendInternalLogToServer()}})),p.onViewContact&&t.core.onViewContact(p.onViewContact),L.onUpstream(t.EventType.UPDATE_CONNECTED_CCPS,(function(e){t.numberOfConnectedCCPs=e.length})),L.onUpstream(t.VoiceIdEvents.UPDATE_DOMAIN_ID,(function(e){e&&e.domainId&&(t.core.voiceIdDomainId=e.domainId)})),t.core.getEventBus().subscribe(t.EventType.IFRAME_RETRIES_EXHAUSTED,(function(){if(l){var e=t.core.iframeRefreshAttempt-1;t.getLog().info("Iframe initialization failed").sendInternalLogToServer(),t.getLog().info("Time after iframe initialization started ".concat(Date.now()-l)).sendInternalLogToServer(),t.getLog().info("Iframe refresh attempts ".concat(e)).sendInternalLogToServer(),t.publishMetric({name:f,data:{count:e}}),t.publishMetric({name:v,data:{count:0}}),p.disasterRecoveryOn&&(t.publishMetric({name:g,data:{count:e}}),t.publishMetric({name:b,data:{count:0}})),l=null}})),t.core.softphoneParams=p.softphone}},t.core._openPopupWithLock=function(e,n){var r="connect-login-popup-lock"+e;try{navigator.locks.request(r,{mode:"exclusive",ifAvailable:!0},function(){var r,a=(r=o().mark((function r(i){var a;return o().wrap((function(r){for(;;)switch(r.prev=r.next){case 0:if(i){r.next=3;break}return t.getLog().info("Popup already opened by another tab.").sendInternalLogToServer(),r.abrupt("return");case 3:t.getLog().info("Opening popup window with weblock.").sendInternalLogToServer(),t.core.loginWindow=t.core.getPopupManager().open(e,t.MasterTopics.LOGIN_POPUP,n),t.core._shouldHoldPopupLock=!0,a=setInterval((function(){var e;(!t.core.loginWindow||null!==(e=t.core.loginWindow)&&void 0!==e&&e.closed)&&(clearInterval(a),t.core._shouldHoldPopupLock=!1,t.getLog().info("Cleared check popup interval.").sendInternalLogToServer())}),1e3);case 7:if(!t.core._shouldHoldPopupLock){r.next=12;break}return r.next=10,new Promise((function(e){return setTimeout(e,1e3)}));case 10:r.next=7;break;case 12:t.getLog().info("Releasing weblock for opening login popup.").sendInternalLogToServer();case 13:case"end":return r.stop()}}),r)})),function(){var e=this,t=arguments;return new Promise((function(n,o){var a=r.apply(e,t);function s(e){i(a,n,o,s,c,"next",e)}function c(e){i(a,n,o,s,c,"throw",e)}s(void 0)}))});return function(e){return a.apply(this,arguments)}}())}catch(r){t.getLog().error("Failed to use weblock to open popup. Your browser may be out of date.").withException(r).sendInternalLogToServer(),t.core.loginWindow||(t.core.loginWindow=t.core.getPopupManager().open(e,t.MasterTopics.LOGIN_POPUP,n))}},t.core.onIframeRetriesExhausted=function(e){return t.core.getEventBus().subscribe(t.EventType.IFRAME_RETRIES_EXHAUSTED,e)},t.core._refreshIframeOnTimeout=function(n,r,o,i){t.assertNotNull(n,"initCCPParams"),t.assertNotNull(r,"containerDiv");var a=o||t.core,s=n.ccpLoadTimeout?n.ccpLoadTimeout:n.disasterRecoveryOn?1e4:5e3;e.clearTimeout(a.iframeRefreshTimeout),a.iframeRefreshTimeout=e.setTimeout((function(){a.iframeRefreshAttempt=(a.iframeRefreshAttempt||0)+1,a.iframeRefreshAttempt<=10?(t.getLog().info("Refreshing the CCP IFrame for ".concat(n.ccpUrl," on attempt ").concat(a.iframeRefreshAttempt)).sendInternalLogToServer(),t.core._replaceCCPIframe(r,n,i),t.core._refreshIframeOnTimeout(n,r,o,i)):(t.core.getEventBus().trigger(t.EventType.IFRAME_RETRIES_EXHAUSTED,i),e.clearTimeout(a.iframeRefreshTimeout))}),s)},t.core._replaceCCPIframe=function(e,n,r){try{var o=t.core._getCCPIframe(r),i=null;o&&(i=o.style,o.parentNode.removeChild(o));var a=t.core._createCCPIframe(e,n,r);i&&(a.style=i.cssText),t.core.getUpstream()instanceof t.GRProxyIframeConduit?t.core.upstream.getAllConduits().forEach((function(e){e.iframe.dataset.identifier===r&&(e.upstream.output=a.contentWindow,e.iframe=a)})):t.core.getUpstream().upstream.output=a.contentWindow,t.core._sendIframeStyleDataUpstreamAfterReasonableWaitTime(a,t.core.upstream)}catch(e){t.getLog().error("Error while checking for, and recreating, the CCP IFrame").withException(e).sendInternalLogToServer()}},t.core._getCCPIframe=function(e){var t,n=u(window.document.getElementsByTagName("iframe"));try{for(n.s();!(t=n.n()).done;){var o,i=t.value;if(i.name===r&&(!e||(null===(o=i.dataset)||void 0===o?void 0:o.identifier)===e))return i}}catch(e){n.e(e)}finally{n.f()}return null},t.core._createCCPIframe=function(e,n,o){var i;t.assertNotNull(n,"initCCPParams"),t.assertNotNull(e,"containerDiv");var a=document.createElement("iframe");if(a.src=n.ccpUrl,a.allow="microphone; camera; autoplay; clipboard-write; identity-credentials-get",a.style=n.style||t.core.iframeStyle,a.title=n.iframeTitle||r,a.name=r,o&&(a.dataset.identifier=o),t.storageAccess.canRequest()&&(a.src=t.storageAccess.getRequestStorageAccessUrl(),a.addEventListener("load",t.storageAccess.request)),null!==(i=t.core._amazonConnectProviderData)&&void 0!==i&&i.isStreamsProvider)try{t.core._amazonConnectProviderData.provider.setCCPIframe(a)}catch(e){t.getLog().error("Error occurred when setting CCP iframe to provider").withException(e).sendInternalLogToServer()}return e.appendChild(a),a},t.core._hideIframe=function(e){e.style=t.core.iframeStyle+"display: none;"},t.core._showIframe=function(e){e.style=t.core.iframeStyle},t.core._sendIframeStyleDataUpstreamAfterReasonableWaitTime=function(e,n){t.assertNotNull(e,"iframe"),t.assertNotNull(n,"conduit"),setTimeout((function(){var r={display:window.getComputedStyle(e,null).display,offsetWidth:e.offsetWidth,offsetHeight:e.offsetHeight,clientRectsLength:e.getClientRects().length};n.sendUpstream(t.EventType.IFRAME_STYLE,r)}),1e4)},t.core.getSDKClientConfig=function(){var e;if(!t.core._amazonConnectProviderData)throw new Error("Provider is not initialized");return{provider:null===(e=t.core._amazonConnectProviderData)||void 0===e?void 0:e.provider}};var N=function(e,t,n,r){this.conduit=e,this.eventBus=t,this.synTimeout=n,this.ackTimeout=r,this.ackTimer=null,this.synTimer=null,this.ackSub=null};N.prototype.start=function(){var n=this;this.conduit.sendUpstream(t.EventType.SYNCHRONIZE),this.ackSub=this.conduit.onUpstream(t.EventType.ACKNOWLEDGE,(function(){this.unsubscribe(),e.clearTimeout(n.ackTimer),n._deferStart()})),this.ackTimer=e.setTimeout((function(){n.ackSub.unsubscribe(),t.isActiveConduit(n.conduit)?(t.getLog().info("ACK_TIMEOUT event is detected from the KeepaliveManager. ".concat(n.conduit.name)).sendInternalLogToServer(),n.eventBus.trigger(t.EventType.ACK_TIMEOUT)):t.getLog().warn("ACK_TIMEOUT event is detected from the KeepaliveManager but suppressed as it is from an inactive region. ".concat(n.conduit.name)).sendInternalLogToServer(),n._deferStart()}),this.ackTimeout)},N.prototype._deferStart=function(){this.synTimer=e.setTimeout(t.hitch(this,this.start),this.synTimeout)},N.prototype.deferStart=function(){null==this.synTimer&&(this.synTimer=e.setTimeout(t.hitch(this,this.start),this.synTimeout))};var P=function(){var e={initFailure:new Set,subscriptionUpdate:new Set,subscriptionFailure:new Set,topic:new Map,allMessage:new Set,connectionGain:new Set,connectionLost:new Set,connectionOpen:new Set,connectionClose:new Set},n=function(e,t){e.forEach((function(e){e(t)}))};t.core.getUpstream().onUpstream(t.WebSocketEvents.INIT_FAILURE,(function(){n(e.initFailure)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.CONNECTION_OPEN,(function(t){n(e.connectionOpen,t)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.CONNECTION_CLOSE,(function(t){n(e.connectionClose,t)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.CONNECTION_GAIN,(function(){n(e.connectionGain)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.CONNECTION_LOST,(function(t){n(e.connectionLost,t)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.SUBSCRIPTION_UPDATE,(function(t){n(e.subscriptionUpdate,t)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.SUBSCRIPTION_FAILURE,(function(t){n(e.subscriptionFailure,t)})),t.core.getUpstream().onUpstream(t.WebSocketEvents.ALL_MESSAGE,(function(t){n(e.allMessage,t),e.topic.has(t.topic)&&n(e.topic.get(t.topic),t)})),this.sendMessage=function(e){t.core.getUpstream().sendUpstream(t.WebSocketEvents.SEND,e)},this.onInitFailure=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.initFailure.add(n),function(){return e.initFailure.delete(n)}},this.onConnectionOpen=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.connectionOpen.add(n),function(){return e.connectionOpen.delete(n)}},this.onConnectionClose=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.connectionClose.add(n),function(){return e.connectionClose.delete(n)}},this.onConnectionGain=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.connectionGain.add(n),function(){return e.connectionGain.delete(n)}},this.onConnectionLost=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.connectionLost.add(n),function(){return e.connectionLost.delete(n)}},this.onSubscriptionUpdate=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.subscriptionUpdate.add(n),function(){return e.subscriptionUpdate.delete(n)}},this.onSubscriptionFailure=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.subscriptionFailure.add(n),function(){return e.subscriptionFailure.delete(n)}},this.subscribeTopics=function(e){t.assertNotNull(e,"topics"),t.assertTrue(t.isArray(e),"topics must be a array"),t.core.getUpstream().sendUpstream(t.WebSocketEvents.SUBSCRIBE,e)},this.onMessage=function(n,r){return t.assertNotNull(n,"topicName"),t.assertTrue(t.isFunction(r),"method must be a function"),e.topic.has(n)?e.topic.get(n).add(r):e.topic.set(n,new Set([r])),function(){return e.topic.get(n).delete(r)}},this.onAllMessage=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.allMessage.add(n),function(){return e.allMessage.delete(n)}},this.onDeepHeartbeatSuccess=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.deepHeartbeatSuccess.add(n),function(){return e.deepHeartbeatSuccess.delete(n)}},this.onDeepHeartbeatFailure=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.deepHeartbeatFailure.add(n),function(){return e.deepHeartbeatFailure.delete(n)}},this.onTopicFailure=function(n){return t.assertTrue(t.isFunction(n),"method must be a function"),e.topicFailure.add(n),function(){return e.topicFailure.delete(n)}}};t.core._removeContactFromEndedSet=function(e){try{t.getLog().info("[ContactEvent] Removing contact from ENDED event tracker").withObject({contactId:e}).sendInternalLogToServer(),t.core.endedEventTracker.delete(e),t.getLog().info("[ContactEvent] Removed contact from ENDED event tracker").withObject(t.core.endedEventTracker.entries()).sendInternalLogToServer()}catch(n){t.getLog().error("[ContactEvent] Failed to remove contact from ENDED event tracker").withObject({contactId:e||"unknown"}).withException(n).sendInternalLogToServer()}},t.core._handleEndedEvent=function(e,n){try{t.core.endedEventTracker.has(e)&&S.includes(n)&&(t.getLog().info("[ContactEvent] ENDED was triggered").withObject({contactId:e}).sendInternalLogToServer(),t.core._removeContactFromEndedSet(e))}catch(e){t.getLog().error("[ContactEvent] Failed to handle proper ENDED event being triggered").withException(e).sendInternalLogToServer()}},t.core._shouldTriggerInvalidStateTransition=function(e){if(t.core.endedEventTracker.has(e.contactId))try{return t.getLog().info("[ContactEvent] Contact did not transition to the ENDED state prior to DESTROYED").withObject(e).sendInternalLogToServer(),t.core._removeContactFromEndedSet(e.contactId),!0}catch(e){t.getLog().error("[ContactEvent] Failed to handle invalid state transition error handling").withException(e).sendInternalLogToServer()}return!1};var D=function(e){this.bus=e,this.agentUpdateSubscriber=this.bus.subscribe(t.AgentEvents.UPDATE,t.hitch(this,this.updateAgentData))};D.prototype.updateAgentData=function(e){var n,r=this.agentData;this.agentData=e,null!==(n=t.agent)&&void 0!==n&&n.initialized||(t.agent.initialized=!0,this.bus.trigger(t.AgentEvents.INIT,new t.Agent)),this.bus.trigger(t.AgentEvents.REFRESH,new t.Agent),this._fireAgentUpdateEvents(r)},D.prototype.getAgentData=function(){if(null==this.agentData)throw new t.StateError("No agent data is available yet!");return this.agentData},D.prototype.getContactData=function(e){var n=this.getAgentData(),r=t.find(n.snapshot.contacts,(function(t){return t.contactId===e}));if(null==r)throw new t.StateError("Contact %s no longer exists.",e);return r},D.prototype.getConnectionData=function(e,n){var r=this.getContactData(e),o=t.find(r.connections,(function(e){return e.connectionId===n}));if(null==o)throw new t.StateError("Connection %s for contact %s no longer exists.",n,e);return o},D.prototype.getInstanceId=function(){return this.getAgentData().configuration.routingProfile.routingProfileId.match(/instance\/([0-9a-fA-F|-]+)\//)[1]},D.prototype.getAWSAccountId=function(){return this.getAgentData().configuration.routingProfile.routingProfileId.match(/:([0-9]+):instance/)[1]},D.prototype._diffContacts=function(e){var n={added:{},removed:{},common:{},oldMap:t.index(null==e?[]:e.snapshot.contacts,(function(e){return e.contactId})),newMap:t.index(this.agentData.snapshot.contacts,(function(e){return e.contactId})),endTime:0};return t.keys(n.oldMap).forEach((function(e){t.contains(n.newMap,e)?n.common[e]=n.newMap[e]:n.removed[e]=n.oldMap[e]})),t.keys(n.newMap).forEach((function(e){t.contains(n.oldMap,e)||(n.added[e]=n.newMap[e])})),n.endTime=performance.now(),n},D.prototype._fireAgentUpdateEvents=function(e){var n=this,r=null,o=null==e?t.AgentAvailStates.INIT:e.snapshot.state.name,i=this.agentData.snapshot.state.name,a=null==e?t.AgentStateType.INIT:e.snapshot.state.type,s=this.agentData.snapshot.state.type;a!==s&&t.core.getAgentRoutingEventGraph().getAssociations(this,a,s).forEach((function(e){n.bus.trigger(e,new t.Agent)})),o!==i&&(this.bus.trigger(t.AgentEvents.STATE_CHANGE,{agent:new t.Agent,oldState:o,newState:i}),t.core.getAgentStateEventGraph().getAssociations(this,o,i).forEach((function(e){n.bus.trigger(e,new t.Agent)})));var c=e&&e.snapshot.nextState?e.snapshot.nextState.name:null,u=this.agentData.snapshot.nextState?this.agentData.snapshot.nextState.name:null;c!==u&&u&&n.bus.trigger(t.AgentEvents.ENQUEUED_NEXT_STATE,new t.Agent),r=null!==e?this._diffContacts(e):{added:t.index(this.agentData.snapshot.contacts,(function(e){return e.contactId})),removed:{},common:{},oldMap:{},newMap:t.index(this.agentData.snapshot.contacts,(function(e){return e.contactId})),endTime:performance.now()},t.values(r.added).forEach((function(e){n.bus.trigger(t.ContactEvents.INIT,new t.Contact(e.contactId)),n._fireContactUpdateEvents(e.contactId,t.ContactStateType.INIT,e.state.type)})),t.values(r.removed).forEach((function(e){n.bus.trigger(t.ContactEvents.DESTROYED,new t.ContactSnapshot(e)),n.bus.trigger(t.core.getContactEventName(t.ContactEvents.DESTROYED,e.contactId),new t.ContactSnapshot(e)),n._unsubAllContactEventsForContact(e.contactId)})),t.keys(r.common).forEach((function(e){n._fireContactUpdateEvents(e,r.oldMap[e].state.type,r.newMap[e].state.type)}))},D.prototype._fireContactUpdateEvents=function(e,n,r){var o=this;n!==r&&t.core.getContactEventGraph().getAssociations(this,n,r).forEach((function(n){o.bus.trigger(n,new t.Contact(e)),o.bus.trigger(t.core.getContactEventName(n,e),new t.Contact(e))})),o.bus.trigger(t.ContactEvents.REFRESH,new t.Contact(e)),o.bus.trigger(t.core.getContactEventName(t.ContactEvents.REFRESH,e),new t.Contact(e))},D.prototype._unsubAllContactEventsForContact=function(e){var n=this;t.values(t.ContactEvents).forEach((function(r){n.bus.getSubscriptions(t.core.getContactEventName(r,e)).map((function(e){e.unsubscribe()}))}))},D.prototype.destroy=function(){this.agentUpdateSubscriber.unsubscribe()},t.core.onViewContact=function(e){return t.core.getEventBus().subscribe(t.ContactEvents.VIEW,e)},t.core.viewContact=function(e){t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ContactEvents.VIEW,data:{contactId:e}})},t.core.onActivateChannelWithViewType=function(e){return t.core.getEventBus().subscribe(t.ChannelViewEvents.ACTIVATE_CHANNEL_WITH_VIEW_TYPE,e)},t.core.activateChannelWithViewType=function(e,n,r,o,i){var a={viewType:e,mediaType:n};r&&(a.source=r),o&&(a.caseId=o),a.clientToken=i||t.randomId(),t.core.getUpstream().sendUpstream(t.EventType.BROADCAST,{event:t.ChannelViewEvents.ACTIVATE_CHANNEL_WITH_VIEW_TYPE,data:a})},t.core.triggerTaskCreated=function(e){t.core.getUpstream().upstreamBus.trigger(t.TaskEvents.CREATED,e)},t.core.triggerEmailCreated=function(e){t.core.getUpstream().upstreamBus.trigger(t.EmailEvents.CREATED,e)},t.core.onAccessDenied=function(e){return t.core.getEventBus().subscribe(t.EventType.ACCESS_DENIED,e)},t.core.onAuthFail=function(e){return t.core.getEventBus().subscribe(t.EventType.AUTH_FAIL,e)},t.core.onAuthorizeSuccess=function(e){return t.core.getEventBus().subscribe(t.EventType.AUTHORIZE_SUCCESS,e)},t.core._handleAuthorizeSuccess=function(){window.sessionStorage.setItem(t.SessionStorageKeys.AUTHORIZE_RETRY_COUNT,0)},t.core._handleAuthFail=function(e,n,r){r&&r.authorize?t.core._handleAuthorizeFail(e):t.core._handleCTIAuthFail(n)},t.core._handleAuthorizeFail=function(e){var n=t.core._getAuthRetryCount();if(!t.core.authorizeTimeoutId)if(n<t.core.MAX_AUTHORIZE_RETRY_COUNT_FOR_SESSION){t.core._incrementAuthRetryCount();var r=AWS.util.calculateRetryDelay(n+1||0,{base:2e3});t.core.authorizeTimeoutId=setTimeout((function(){t.core._redirectToLogin(e)}),r)}else t.getLog().warn("We have exhausted our authorization retries due to 401s from the authorize api. No more retries will be attempted in this session until the authorize api returns 200.").sendInternalLogToServer(),t.core.getEventBus().trigger(t.EventType.AUTHORIZE_RETRIES_EXHAUSTED)},t.core._redirectToLogin=function(e){"string"==typeof e?location.assign(e):location.reload()},t.core._handleCTIAuthFail=function(e){if(!t.core.ctiTimeoutId)if(t.core.ctiAuthRetryCount<t.core.MAX_CTI_AUTH_RETRY_COUNT){t.core.ctiAuthRetryCount++;var n=AWS.util.calculateRetryDelay(t.core.ctiAuthRetryCount||0,{base:500});t.core.ctiTimeoutId=setTimeout((function(){t.core.authorize(e).then(t.core._triggerAuthorizeSuccess.bind(t.core)).catch(t.core._triggerAuthFail.bind(t.core,{authorize:!0})),t.core.ctiTimeoutId=null}),n)}else t.getLog().warn("We have exhausted our authorization retries due to 401s from the CTI service. No more retries will be attempted until the page is refreshed.").sendInternalLogToServer(),t.core.getEventBus().trigger(t.EventType.CTI_AUTHORIZE_RETRIES_EXHAUSTED)},t.core._triggerAuthorizeSuccess=function(){t.core.getUpstream().upstreamBus.trigger(t.EventType.AUTHORIZE_SUCCESS)},t.core._triggerAuthFail=function(e){t.core.getUpstream().upstreamBus.trigger(t.EventType.AUTH_FAIL,e)},t.core._getAuthRetryCount=function(){var e=window.sessionStorage.getItem(t.SessionStorageKeys.AUTHORIZE_RETRY_COUNT);if(null!==e){if(isNaN(parseInt(e)))throw new t.StateError("The session storage value for auth retry count was NaN");return parseInt(e)}return window.sessionStorage.setItem(t.SessionStorageKeys.AUTHORIZE_RETRY_COUNT,0),0},t.core._incrementAuthRetryCount=function(){window.sessionStorage.setItem(t.SessionStorageKeys.AUTHORIZE_RETRY_COUNT,(t.core._getAuthRetryCount()+1).toString())},t.core.onAuthorizeRetriesExhausted=function(e){return t.core.getEventBus().subscribe(t.EventType.AUTHORIZE_RETRIES_EXHAUSTED,e)},t.core.onCTIAuthorizeRetriesExhausted=function(e){return t.core.getEventBus().subscribe(t.EventType.CTI_AUTHORIZE_RETRIES_EXHAUSTED,e)},t.core.onSoftphoneSessionInit=function(e){return t.core.getEventBus().subscribe(t.ConnectionEvents.SESSION_INIT,e)},t.core.onConfigure=function(e){return t.core.getEventBus().subscribe(t.ConfigurationEvents.CONFIGURE,e)},t.core.onInitialized=function(e){return t.core.getEventBus().subscribe(t.EventType.INIT,e)},t.core.getContactEventName=function(e,n){if(t.assertNotNull(e,"eventName"),t.assertNotNull(n,"contactId"),!t.contains(t.values(t.ContactEvents),e))throw new t.ValueError("%s is not a valid contact event.",e);return t.sprintf("%s::%s",e,n)},t.core.getEventBus=function(){return t.core.eventBus},t.core.getWebSocketManager=function(){return t.core.webSocketProvider},t.core.getAgentDataProvider=function(){return t.core.agentDataProvider},t.core.getLocalTimestamp=function(){return t.core.getAgentDataProvider().getAgentData().snapshot.localTimestamp},t.core.getSkew=function(){return t.core.getAgentDataProvider().getAgentData().snapshot.skew},t.core.getAgentRoutingEventGraph=function(){return t.core.agentRoutingEventGraph},t.core.agentRoutingEventGraph=(new t.EventGraph).assoc(t.EventGraph.ANY,t.AgentStateType.ROUTABLE,t.AgentEvents.ROUTABLE).assoc(t.EventGraph.ANY,t.AgentStateType.NOT_ROUTABLE,t.AgentEvents.NOT_ROUTABLE).assoc(t.EventGraph.ANY,t.AgentStateType.OFFLINE,t.AgentEvents.OFFLINE),t.core.getAgentStateEventGraph=function(){return t.core.agentStateEventGraph},t.core.agentStateEventGraph=(new t.EventGraph).assoc(t.EventGraph.ANY,t.values(t.AgentErrorStates),t.AgentEvents.ERROR).assoc(t.EventGraph.ANY,t.AgentAvailStates.AFTER_CALL_WORK,t.AgentEvents.ACW),t.core.getContactEventGraph=function(){return t.core.contactEventGraph},t.core.contactEventGraph=(new t.EventGraph).assoc(t.EventGraph.ANY,t.ContactStateType.INCOMING,t.ContactEvents.INCOMING).assoc(t.EventGraph.ANY,t.ContactStateType.PENDING,t.ContactEvents.PENDING).assoc(t.EventGraph.ANY,t.ContactStateType.CONNECTING,t.ContactEvents.CONNECTING).assoc(t.EventGraph.ANY,t.ContactStateType.CONNECTED,t.ContactEvents.CONNECTED).assoc(t.ContactStateType.CONNECTING,t.ContactStateType.ERROR,t.ContactEvents.MISSED).assoc(t.ContactStateType.INCOMING,t.ContactStateType.ERROR,t.ContactEvents.MISSED).assoc(t.EventGraph.ANY,t.ContactStateType.ENDED,t.ContactEvents.ACW).assoc(t.values(t.CONTACT_ACTIVE_STATES),t.values(t.relativeComplement(t.CONTACT_ACTIVE_STATES,t.ContactStateType)),t.ContactEvents.ENDED).assoc(t.EventGraph.ANY,t.ContactStateType.ERROR,t.ContactEvents.ERROR).assoc(t.ContactStateType.CONNECTING,t.ContactStateType.MISSED,t.ContactEvents.MISSED).assoc(t.ContactStateType.INCOMING,t.ContactStateType.MISSED,t.ContactEvents.MISSED).assoc(t.ContactStateType.CONNECTING,t.ContactStateType.REJECTED,t.ContactEvents.MISSED).assoc(t.ContactStateType.INCOMING,t.ContactStateType.REJECTED,t.ContactEvents.MISSED),t.core.getClient=function(){if(!t.core.client)throw new t.StateError("The connect core has not been initialized!");return t.core.client},t.core.client=null,t.core.getApiProxyClient=function(){if(!t.core.apiProxyClient)throw new t.StateError("The connect apiProxy Client has not been initialized!");return t.core.apiProxyClient},t.core.apiProxyClient=null,t.core.getAgentAppClient=function(){if(!t.core.agentAppClient)throw new t.StateError("The connect AgentApp Client has not been initialized!");return t.core.agentAppClient},t.core.agentAppClient=null,t.core.getTaskTemplatesClient=function(){if(!t.core.taskTemplatesClient)throw new t.StateError("The connect TaskTemplates Client has not been initialized!");return t.core.taskTemplatesClient},t.core.taskTemplatesClient=null,t.core.getMasterClient=function(){if(!t.core.masterClient)throw new t.StateError("The connect master client has not been initialized!");return t.core.masterClient},t.core.masterClient=null,t.core.getSoftphoneManager=function(){return t.core.softphoneManager},t.core.softphoneManager=null,t.core.getNotificationManager=function(){return t.core.notificationManager||(t.core.notificationManager=new t.NotificationManager),t.core.notificationManager},t.core.notificationManager=null,t.core.getPopupManager=function(){return t.core.popupManager},t.core.popupManager=new t.PopupManager,t.core.getUpstream=function(){if(!t.core.upstream)throw new t.StateError("There is no upstream conduit!");return t.core.upstream},t.core.upstream=null,t.globalResiliency.onFailoverPending=function(e){return t.core.getEventBus().subscribe(t.GlobalResiliencyEvents.FAILOVER_PENDING_CRM,e)},t.globalResiliency.onFailoverCompleted=function(e){return t.core.getEventBus().subscribe(t.GlobalResiliencyEvents.FAILOVER_COMPLETE,e)},t.globalResiliency.onConfigureError=function(e){return t.core.getEventBus().subscribe(t.GlobalResiliencyEvents.CONFIGURE_ERROR,e)},t.globalResiliency.getActiveRegion=function(){return t.globalResiliency._activeRegion},t.core.AgentDataProvider=D,t.WebSocketProvider=P,t.KeepaliveManager=N}()},682:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t;var n="<<all>>",r=t.makeEnum(["acknowledge","ack_timeout","init","api_request","api_response","auth_fail","access_denied","close","configure","log","download_log_from_ccp","master_request","master_response","synchronize","terminate","terminated","send_logs","reload_agent_configuration","broadcast","api_metric","client_metric","softphone_stats","softphone_report","client_side_logs","server_bound_internal_log","mute","iframe_style","iframe_retries_exhausted","update_connected_ccps","outer_context_info","media_device_request","media_device_response","tab_id","authorize_success","authorize_retries_exhausted","cti_authorize_retries_exhausted","click_stream_data","set_quick_get_agent_snapshot_flag","api_proxy_request","api_proxy_response"]),o=t.makeNamespacedEnum("connect",["loginPopup","sendLogs","softphone","ringtone","metrics","failover"]),i=t.makeNamespacedEnum("agent",["init","update","refresh","routable","not_routable","pending","contact_pending","offline","error","softphone_error","websocket_connection_lost","websocket_connection_gained","state_change","acw","mute_toggle","local_media_stream_created","enqueued_next_state","fetch_agent_data_from_ccp"]),a=t.makeNamespacedEnum("webSocket",["init_failure","connection_open","connection_close","connection_error","connection_gain","connection_lost","subscription_update","subscription_failure","all_message","send","subscribe"]),s=t.makeNamespacedEnum("contact",["init","refresh","destroyed","incoming","pending","connecting","connected","missed","acw","view","ended","error","accepted","invalid_state_transition","screen_sharing_started","screen_sharing_stopped","screen_sharing_error"]),c=t.makeNamespacedEnum("taskList",["activate_channel_with_view_type"]),u=t.makeNamespacedEnum("task",["created"]),l=t.makeNamespacedEnum("email",["created"]),p=t.makeNamespacedEnum("connection",["session_init","ready_to_start_session"]),d=t.makeNamespacedEnum("configuration",["configure","set_speaker_device","set_microphone_device","set_ringer_device","speaker_device_changed","microphone_device_changed","ringer_device_changed","camera_device_changed","background_blur_changed"]),f=t.makeNamespacedEnum("disasterRecovery",["suppress","force_offline","set_offline","init_disaster_recovery","failover","failover_pending","init_dr_polling"]),h=t.makeNamespacedEnum("globalResiliency",["configure","configure_ccp_conduit","init","configure_error","failover_initiated","failover_pending","failover_pending_crm","failover_complete","heartbeat_syn","heartbeat_ack"]),g=t.makeNamespacedEnum("voiceId",["update_domain_id"]),m=function(){};m.createRequest=function(e,n,r){return{event:e,requestId:t.randomId(),method:n,params:r}},m.createResponse=function(e,t,n,r){return{event:e,requestId:t.requestId,data:n,err:r||null}};var v=function(e,n,r){this.subMap=e,this.id=t.randomId(),this.eventName=n,this.f=r};v.prototype.unsubscribe=function(){this.subMap.unsubscribe(this.eventName,this.id)};var y=function(){this.subIdMap={},this.subEventNameMap={}};y.prototype.subscribe=function(e,t){var n=new v(this,e,t);this.subIdMap[n.id]=n;var r=this.subEventNameMap[e]||[];return r.push(n),this.subEventNameMap[e]=r,n},y.prototype.unsubscribe=function(e,n){t.contains(this.subEventNameMap,e)&&(this.subEventNameMap[e]=this.subEventNameMap[e].filter((function(e){return e.id!==n})),this.subEventNameMap[e].length<1&&delete this.subEventNameMap[e]),t.contains(this.subIdMap,n)&&delete this.subIdMap[n]},y.prototype.getAllSubscriptions=function(){return t.values(this.subEventNameMap).reduce((function(e,t){return e.concat(t)}),[])},y.prototype.getSubscriptions=function(e){return this.subEventNameMap[e]||[]};var b=function(e){var t=e||{};this.subMap=new y,this.logEvents=t.logEvents||!1};b.prototype.subscribe=function(e,n){return t.assertNotNull(e,"eventName"),t.assertNotNull(n,"f"),t.assertTrue(t.isFunction(n),"f must be a function"),this.subMap.subscribe(e,n)},b.prototype.subscribeAll=function(e){return t.assertNotNull(e,"f"),t.assertTrue(t.isFunction(e),"f must be a function"),this.subMap.subscribe(n,e)},b.prototype.getSubscriptions=function(e){return this.subMap.getSubscriptions(e)},b.prototype.trigger=function(e,r){t.assertNotNull(e,"eventName");var o=this,i=this.subMap.getSubscriptions(n),a=this.subMap.getSubscriptions(e);this.logEvents&&e!==t.EventType.LOG&&e!==t.EventType.MASTER_RESPONSE&&e!==t.EventType.API_METRIC&&e!==t.EventType.SERVER_BOUND_INTERNAL_LOG&&t.getLog().trace("Publishing event: %s",e).sendInternalLogToServer(),e.startsWith(t.ContactEvents.ACCEPTED)&&r&&r.contactId&&!(r instanceof t.Contact)&&(r=new t.Contact(r.contactId)),i.concat(a).forEach((function(n){try{n.f(r||null,e,o)}catch(n){t.getLog().error("'%s' event handler failed.",e).withException(n).sendInternalLogToServer()}}))},b.prototype.bridge=function(){var e=this;return function(t,n){e.trigger(n,t)}},b.prototype.unsubscribeAll=function(){this.subMap.getAllSubscriptions().forEach((function(e){e.unsubscribe()}))},t.EventBus=b,t.EventFactory=m,t.EventType=r,t.AgentEvents=i,t.ConfigurationEvents=d,t.ConnectionEvents=p,t.ConnnectionEvents=p,t.ContactEvents=s,t.ChannelViewEvents=c,t.TaskEvents=u,t.EmailEvents=l,t.VoiceIdEvents=g,t.WebSocketEvents=a,t.MasterTopics=o,t.DisasterRecoveryEvents=f,t.GlobalResiliencyEvents=h}()},949:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(t,n,r){return(n=function(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}(n))in t?Object.defineProperty(t,n,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[n]=r,t}!function(){var t=this||globalThis,r=t.connect||{};t.connect=r;var o="IframeRefreshAttempts",i="IframeInitializationSuccess";r.globalResiliency._downloadCCPLogs=function(){r.core.getEventBus().trigger(r.EventType.DOWNLOAD_LOG_FROM_CCP)},r.globalResiliency._initializeActiveRegion=function(e,t){try{var o;null===(o=r.core.agentDataProvider)||void 0===o||o.destroy(),r.core.agentDataProvider=new r.core.AgentDataProvider(r.core.getEventBus()),e.getActiveConduit().sendUpstream(r.AgentEvents.FETCH_AGENT_DATA_FROM_CCP)}catch(e){r.getLog().error("[GR] There was an error reinitializing the agent data provider.").withException(e).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencySwitchRegionAgentDataProviderFailure",data:{count:1}})}r.core.keepaliveManager=e.getActiveConduit().keepaliveManager,r.core.client=new r.UpstreamConduitClient(e.getActiveConduit()),r.core.masterClient=new r.UpstreamConduitMasterClient(e.getActiveConduit()),r.core.mediaFactory=new r.MediaFactory(n(n({},r.globalResiliency.params),{},{ccpUrl:e.getActiveConduit().name}));try{var i;null!==(i=r.core)&&void 0!==i&&i.softphoneManager?r.core._allowSoftphonePersistentConnection?(r.getLog().info("[GR] Refreshing softphone manager RTC peer connection manager.").sendInternalLogToServer(),r.core.softphoneManager._initiateRtcPeerConnectionManager()):(r.getLog().info("[GR] Refreshing softphone manager RTC peer connection factory.").sendInternalLogToServer(),r.core.softphoneManager._refreshRtcPeerConnectionFactory()):r.getLog().info("[GR] Softphone manager not initialized or not used, not refreshing softphone manager.").sendInternalLogToServer()}catch(e){r.getLog().error("[GR] There was an error refreshing the softphone manager.").withException(e).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencySwitchRegionWebRTCFailure",data:{count:1}})}t&&(r.globalResiliency._activeRegion=t,r.ChatSession?r.ChatSession.setRegionOverride?(r.getLog().info("[GR] Updating ChatJS region to ".concat(t)).sendInternalLogToServer(),r.ChatSession.setRegionOverride(t)):r.getLog().warn("[GR] ChatJS present, but setRegionOverride not found. Consider updating to latest ChatJS version").sendInternalLogToServer():r.getLog().info("[GR] ChatJS not present, not updating ChatSession region.").sendInternalLogToServer()),e.getActiveConduit().sendUpstream(r.GlobalResiliencyEvents.CONFIGURE_CCP_CONDUIT,{instanceState:"active"}),e.getInactiveConduit().sendUpstream(r.GlobalResiliencyEvents.CONFIGURE_CCP_CONDUIT,{instanceState:"inactive"});try{r.core._showIframe(e.getActiveConduit().iframe),r.core._hideIframe(e.getInactiveConduit().iframe)}catch(e){r.getLog().error("[GR] There was an error updating the IFrame visibility.").withException(e).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencySwitchRegionIFrameSwapFailure",data:{count:1}})}},r.globalResiliency._switchActiveRegion=function(t,n){var o,i,a,s,c;if(!(t instanceof r.GRProxyIframeConduit))return r.getLog().error("[GR] Tried to switch over active region, but proxy conduit was not of expected type.").withObject({type:e(t)}).sendInternalLogToServer(),!1;var u=t.getConduitByName(n);return u instanceof r.IFrameConduit?t.getActiveConduit().name===u.name&&r.globalResiliency._activeRegion===u.region?(r.getLog().info("[GR] Not switching over active region as we are already on active region.").sendInternalLogToServer(),!1):(r.getLog().info("[GR] Switching active region from ".concat(null===(o=t.getActiveConduit())||void 0===o?void 0:o.region," / ").concat(null===(i=t.getActiveConduit())||void 0===i?void 0:i.name," to ").concat(null==u?void 0:u.region," / ").concat(null==u?void 0:u.name)).sendInternalLogToServer(),null===(a=r.core)||void 0===a||null===(a=a.softphoneManager)||void 0===a||a._clearAllSessions(),t.setActiveConduit(u.name),r.globalResiliency._initializeActiveRegion(t,u.region),r.getLog().info("[GR] Switched active region to ".concat(null===(s=t.getActiveConduit())||void 0===s?void 0:s.region," / ").concat(null===(c=t.getActiveConduit())||void 0===c?void 0:c.name)).sendInternalLogToServer(),r.publishMetric({name:"CalledInternalSwitchActiveRegionSuccessful",data:{count:1}}),!0):(r.getLog().error("[GR] Tried to switch over active region, but conduit name was invalid").withObject({newActiveConduitName:n}).sendInternalLogToServer(),!1)},r.globalResiliency.initGRCCP=function(e,a){var s=n(n({},a),{},{loginOptions:{legacyAuthFlow:!0}});r.globalResiliency.params=s;var c,u,l,p={},d=!1;if(r.globalResiliency._activeRegion=null,r.globalResiliency.globalResiliencyEnabled=!0,r.core.checkNotInitialized(),!r.core.initialized){r.getLog().info("[GR] Iframe initialization started").sendInternalLogToServer();var f=Date.now();r.assertNotNull(e,"containerDiv");var h=new URL(s.ccpUrl).origin,g=new URL(s.secondaryCCPUrl).origin,m=r.core._createCCPIframe(e,s,h),v=r.core._createCCPIframe(e,n(n({},s),{},{ccpUrl:s.secondaryCCPUrl}),g),y=new r.GRProxyIframeConduit(window,[m,v],m.src);r.core.upstream=y,r.core.eventBus=new r.EventBus({logEvents:!1}),r.globalResiliency._initializeActiveRegion(y),r.publishMetric({name:"InitGlobalResiliencyCCPCalled",data:{count:1}}),y.getAllConduits().forEach((function(e){r.core._sendIframeStyleDataUpstreamAfterReasonableWaitTime(e.iframe,e)})),r.core.webSocketProvider=new r.WebSocketProvider,y.onAllUpstream(r.core.getEventBus().bridge()),y.getAllConduits().forEach((function(e){e.keepaliveManager=new r.KeepaliveManager(e,r.core.getEventBus(),s.ccpSynTimeout||1e3,s.ccpAckTimeout||3e3)})),r.getLog().scheduleUpstreamOuterContextCCPLogsPush(y),r.getLog().scheduleUpstreamOuterContextCCPserverBoundLogsPush(y),y.onUpstream(r.AgentEvents.FETCH_AGENT_DATA_FROM_CCP,(function(e){r.core.getAgentDataProvider().updateAgentData(e),r.getLog().info("[GR] Fetched agent data from CCP.").sendInternalLogToServer()})),y.getAllConduits().forEach((function(e){p[e.name]={iframeRefreshTimeout:null},p[e.name].ccpLoadTimeoutInstance=setTimeout((function(){p[e.name].ccpLoadTimeoutInstance=null,r.isActiveConduit(e)?(r.core.getEventBus().trigger(r.EventType.ACK_TIMEOUT),r.getLog().info("CCP LoadTimeout triggered. ".concat(e.name)).sendInternalLogToServer()):r.getLog().error("CCP LoadTimeout detected but ignored for non-primary regions. ".concat(e.name)).sendInternalLogToServer()}),s.ccpLoadTimeout||5e3)})),y.getAllConduits().forEach((function(e){e.onUpstream(r.EventType.ACKNOWLEDGE,(function(n){if(r.getLog().info("Acknowledged by the CCP! ".concat(e.name)).sendInternalLogToServer(),e.sendUpstream(r.EventType.CONFIGURE,{softphone:s.softphone,chat:s.chat,pageOptions:s.pageOptions,shouldAddNamespaceToLogs:s.shouldAddNamespaceToLogs,enableGlobalResiliency:s.enableGlobalResiliency,instanceState:r.isActiveConduit(e)?"active":"inactive"}),p[e.name].ccpLoadTimeoutInstance&&(t.clearTimeout(p[e.name].ccpLoadTimeoutInstance),p[e.name].ccpLoadTimeoutInstance=null),e.sendUpstream(r.EventType.OUTER_CONTEXT_INFO,{streamsVersion:r.version,initCCPParams:s}),e.keepaliveManager.start(),r.isActiveConduit(e)&&(r.core.client=new r.UpstreamConduitClient(e),r.core.masterClient=new r.UpstreamConduitMasterClient(e),r.core.portStreamId=n.id,f)){var a=Date.now()-f,c=p[e.name].iframeRefreshAttempt||0;r.getLog().info("Iframe initialization succeeded").sendInternalLogToServer(),r.getLog().info("Iframe initialization time ".concat(a)).sendInternalLogToServer(),r.getLog().info("Iframe refresh attempts ".concat(c)).sendInternalLogToServer(),setTimeout((function(){r.publishMetric({name:o,data:{count:c}}),r.publishMetric({name:i,data:{count:1}}),r.publishMetric({name:"IframeInitializationTime",data:{count:a}}),f=null}),1e3)}e.portStreamId=n.id,this.unsubscribe()}))})),y.onUpstream(r.EventType.LOG,(function(e){e.loggerId!==r.getLog().getLoggerId()&&r.getLog().addLogEntry(r.LogEntry.fromObject(e))})),r.core.getEventBus().subscribe(r.EventType.ACK_TIMEOUT,(function(){if(!1!==s.loginPopup)try{var o=s.loginUrl;r.getLog().warn("ACK_TIMEOUT occurred, attempting to pop the login page if not already open.").sendInternalLogToServer(),r.core.getPopupManager().clear(r.MasterTopics.LOGIN_POPUP),r.core._openPopupWithLock(o,s.loginOptions)}catch(e){r.getLog().error("ACK_TIMEOUT occurred but we are unable to open the login popup.").withException(e).sendInternalLogToServer()}y.getAllConduits().forEach((function(o){if(null===p[o.name].iframeRefreshTimeout)try{o.onUpstream(r.EventType.ACKNOWLEDGE,(function(){this.unsubscribe(),t.clearTimeout(p[o.name].iframeRefreshTimeout),p[o.name].iframeRefreshTimeout=null,r.core.getPopupManager().clear(r.MasterTopics.LOGIN_POPUP),(s.loginPopupAutoClose||s.loginOptions&&s.loginOptions.autoClose)&&r.core.loginWindow&&(r.core.loginWindow.close(),r.core.loginWindow=null)})),r.core._refreshIframeOnTimeout(n(n({},s),{},{ccpUrl:o.iframe.src}),e,p[o.name],o.name)}catch(e){r.getLog().error("Error occurred while refreshing iframe").withException(e).sendInternalLogToServer()}}))})),y.getAllConduits().forEach((function(e){e.onUpstream(r.GlobalResiliencyEvents.INIT,(function(t){if(null!=t&&t.instanceRegion&&null!=t&&t.instanceState&&null!=t&&t.activeRegion){r.getLog().info("[GR] Received GlobalResiliencyEvents.INIT indicating ".concat(e.name," in region ").concat(null==t?void 0:t.instanceRegion," is ").concat(null==t?void 0:t.instanceState,".")).withObject({data:t}).sendInternalLogToServer();var n=t.instanceRegion===t.activeRegion?e:y.getOtherConduit(e);if(e.region&&n.region||(e.region=t.instanceRegion,n.region=t.activeRegion),e.sendUpstream(r.GlobalResiliencyEvents.CONFIGURE_CCP_CONDUIT,{instanceState:t.instanceState}),r.core.initialized)r.getLog().log("[GR] Deduping GlobalResiliencyEvents.INIT - Core is already initialized.").sendInternalLogToServer();else{r.getLog().info("[GR] Setting initial active iframe to ".concat(n.name," in region ").concat(n.region," because the instance state was active")).sendInternalLogToServer();try{r.globalResiliency._switchActiveRegion(y,n.name),r.publishMetric({name:"GlobalResiliencySwitchRegionSuccess",data:{count:1}})}catch(e){r.getLog().error("[GR] Failure switching active region at initialization.").withException(e).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencySwitchRegionFailure",data:{count:1}})}r.core.getEventBus().trigger(r.EventType.INIT),r.core.initialized=!0,r.publishMetric({name:"GlobalResiliencyCoreInitialized",data:{count:1}})}}else r.getLog().error("[GR] Expected GlobalResiliencyEvents.INIT to have instance region, state, and current active region, but did not find it.").withObject({data:t}).sendInternalLogToServer()})),e.onUpstream(r.GlobalResiliencyEvents.FAILOVER_INITIATED,(function(e){if(u=Date.now(),r.publishMetric({name:"GlobalResiliencyFailoverInitiatedReceived",data:{count:1}}),d&&r.publishMetric({name:"GlobalResiliencyPendingToInitiatedLatency",data:{latency:u-c}}),null!=e&&e.activeRegion){r.getLog().info("[GR] Received GlobalResiliencyEvents.FAILOVER_INITIATED indicating the activeRegion is ".concat(e.activeRegion,"."));var t,n=y.getConduitByRegion(e.activeRegion);n||(r.getLog().debug("[GR] A conduit did not received GLOBAL_RESILIENCY.INIT event, leading to the region field being unpopulated."),y.getAllConduits().forEach((function(t){void 0!==t.region&&null!==t.region||(t.region=e.activeRegion,n=t)})));try{t=r.globalResiliency._switchActiveRegion(y,n.name),r.publishMetric({name:"GlobalResiliencySwitchRegionSuccess",data:{count:1}})}catch(e){r.getLog().error("[GR] Failure switching active region.").withException(e).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencySwitchRegionFailure",data:{count:1}})}if(t){d=!1;var o=y.onUpstream(r.AgentEvents.UPDATE,(function(){o.unsubscribe(),r.core.getEventBus().trigger(r.GlobalResiliencyEvents.FAILOVER_COMPLETE,{activeRegion:e.activeRegion}),y.sendUpstream(r.GlobalResiliencyEvents.FAILOVER_COMPLETE),r.getLog().info("[GR] GlobalResiliencyEvents.FAILOVER_COMPLETE emitted.").sendInternalLogToServer(),l=Date.now(),r.publishMetric({name:"GlobalResiliencyFailoverCompleted",data:{count:1}}),r.publishMetric({name:"GlobalResiliencyInitiatedToCompletedLatency",data:{latency:l-u}})}))}}else r.getLog().error("[GR] Expected GlobalResiliencyEvents.FAILOVER_INITIATED to have new active region, but did not find it.").withObject({data:e}).sendInternalLogToServer()}))})),s.onViewContact&&r.core.onViewContact(s.onViewContact),y.onUpstream(r.EventType.UPDATE_CONNECTED_CCPS,(function(e){r.numberOfConnectedCCPs=e.length})),y.getAllConduits().forEach((function(e){e.onUpstream(r.VoiceIdEvents.UPDATE_DOMAIN_ID,(function(t){t&&t.domainId&&(e.voiceIdDomainId=t.domainId,r.isActiveConduit(e)&&(r.core.voiceIdDomainId=t.domainId))}))})),r.core.getEventBus().subscribe(r.EventType.IFRAME_RETRIES_EXHAUSTED,(function(e){if(e===y.getActiveConduit().name&&f){var t=p[y.getActiveConduit().name].iframeRefreshAttempt-1;r.getLog().info("Iframe initialization failed").sendInternalLogToServer(),r.getLog().info("Time after iframe initialization started ".concat(Date.now()-f)).sendInternalLogToServer(),r.getLog().info("Iframe refresh attempts ".concat(t)).sendInternalLogToServer(),r.publishMetric({name:o,data:{count:t}}),r.publishMetric({name:i,data:{count:0}}),f=null}})),r.core.softphoneParams=s.softphone,y.getAllConduits().forEach((function(e){e.onUpstream(r.GlobalResiliencyEvents.FAILOVER_PENDING,(function(t){r.isActiveConduit(e)&&(d?r.getLog().info("[GR] Received FAILOVER_PENDING - deduping, will not trigger event subscription.").withObject({data:t}).sendInternalLogToServer():(r.getLog().info("[GR] Received FAILOVER_PENDING").withObject({data:t}).sendInternalLogToServer(),r.core.getEventBus().trigger(r.GlobalResiliencyEvents.FAILOVER_PENDING_CRM,{nextActiveRegion:t.activeRegion}),d=!0,c=Date.now(),r.publishMetric({name:"GlobalResiliencyFailoverPendingReceived",data:{count:1}})))}))})),y.relayUpstream(r.GlobalResiliencyEvents.FAILOVER_PENDING),y.relayUpstream(r.GlobalResiliencyEvents.FAILOVER_INITIATED),y.relayUpstream(r.GlobalResiliencyEvents.FAILOVER_COMPLETE),y.relayUpstream(r.GlobalResiliencyEvents.HEARTBEAT_SYN),y.relayUpstream(r.GlobalResiliencyEvents.HEARTBEAT_ACK),r.core.getEventBus().subscribe(r.EventType.DOWNLOAD_LOG_FROM_CCP,(function(){y.getAllConduits().forEach((function(e){var t=e.region||"region";e.sendUpstream(r.EventType.DOWNLOAD_LOG_FROM_CCP,{logName:"ccp-".concat(t,"-agent-log")})}))})),setTimeout((function(){var e=0;y.getAllConduits().forEach((function(t){t.region&&(e+=1)})),e<2&&(r.getLog().info("[GR] One or more conduits did not GlobalResiliency.INIT event to CRM layer.").withObject({firstConduitName:y.getAllConduits()[0].name,firstConduitRegion:y.getAllConduits()[0].region,secondConduitName:y.getAllConduits()[1].name,secondConduitRegion:y.getAllConduits()[1].region}).sendInternalLogToServer(),r.publishMetric({name:"GlobalResiliencyPartialInitialization",data:{count:1}}))}),3e4)}}}()},95:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}!function(t){var n={};function r(e){if(n[e])return n[e].exports;var o=n[e]={i:e,l:!1,exports:{}};return t[e].call(o.exports,o,o.exports,r),o.l=!0,o.exports}r.m=t,r.c=n,r.d=function(e,t,n){r.o(e,t)||Object.defineProperty(e,t,{enumerable:!0,get:n})},r.r=function(e){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},r.t=function(t,n){if(1&n&&(t=r(t)),8&n)return t;if(4&n&&"object"==e(t)&&t&&t.__esModule)return t;var o=Object.create(null);if(r.r(o),Object.defineProperty(o,"default",{enumerable:!0,value:t}),2&n&&"string"!=typeof t)for(var i in t)r.d(o,i,function(e){return t[e]}.bind(null,i));return o},r.n=function(e){var t=e&&e.__esModule?function(){return e.default}:function(){return e};return r.d(t,"a",t),t},r.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},r.p="",r(r.s=2)}([function(t,n,r){"use strict";var o=r(1),i="DEBUG",a="AMZ_WEB_SOCKET_MANAGER:",s="Network offline",c="Network online, connecting to WebSocket server",u="Network offline, ignoring this getWebSocketConnConfig request",l="Heartbeat response not received",p="Failed to send heartbeat since WebSocket is not open",d="WebSocket connection established!",f="WebSocket connection is closed",h="WebSocketManager Error, error_event: ",g="Scheduling WebSocket reinitialization, after delay ",m="WebSocket URL cannot be used to establish connection",v="WebSocket Initialization failed - Terminating and cleaning subscriptions",y="Fetching new WebSocket connection configuration",b="Successfully fetched webSocket connection configuration",E="Failed to fetch webSocket connection configuration",S="Retrying fetching new WebSocket connection configuration",C="Initializing Websocket Manager",T="WebSocketManager Message Error",I="Message received for topic ",w="Invalid incoming message",A="aws/subscribe",_="aws/heartbeat",R="disconnected";function O(t){return(O="function"==typeof Symbol&&"symbol"==e(Symbol.iterator)?function(t){return e(t)}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":e(t)})(t)}var L={assertTrue:function(e,t){if(!e)throw new Error(t)},assertNotNull:function(e,t){return L.assertTrue(null!==e&&void 0!==O(e),Object(o.sprintf)("%s must be provided",t||"A value")),e},isNonEmptyString:function(e){return"string"==typeof e&&e.length>0},assertIsList:function(e,t){if(!Array.isArray(e))throw new Error(t+" is not an array")},isFunction:function(e){return!!(e&&e.constructor&&e.call&&e.apply)},isObject:function(e){return!("object"!==O(e)||null===e)},isString:function(e){return"string"==typeof e},isNumber:function(e){return"number"==typeof e}},k=new RegExp("^(wss://)\\w*");L.validWSUrl=function(e){return k.test(e)},L.getSubscriptionResponse=function(e,t,n){return{topic:e,content:{status:t?"success":"failure",topics:n}}},L.assertIsObject=function(e,t){if(!L.isObject(e))throw new Error(t+" is not an object!")},L.addJitter=function(e){var t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:1;t=Math.min(t,1);var n=Math.random()>.5?1:-1;return Math.floor(e+n*e*Math.random()*t)},L.isNetworkOnline=function(){return navigator.onLine},L.isNetworkFailure=function(e){return!(!e._debug||!e._debug.type)&&"NetworkingError"===e._debug.type};var N=L;function P(e){return(P=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function D(e,t){return(D=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function x(t){return(x="function"==typeof Symbol&&"symbol"==e(Symbol.iterator)?function(t){return e(t)}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":e(t)})(t)}function M(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function U(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}function F(e,t,n){return t&&U(e.prototype,t),n&&U(e,n),e}var j=function(){function e(){M(this,e)}return F(e,[{key:"debug",value:function(e){}},{key:"info",value:function(e){}},{key:"warn",value:function(e){}},{key:"error",value:function(e){}},{key:"advancedLog",value:function(e){}}]),e}(),q=a,B={DEBUG:10,INFO:20,WARN:30,ERROR:40,ADVANCED_LOG:50},G=function(){function e(){M(this,e),this.updateLoggerConfig(),this.consoleLoggerWrapper=H()}return F(e,[{key:"writeToClientLogger",value:function(e,t){if(this.hasClientLogger())switch(e){case B.DEBUG:return this._clientLogger.debug(t)||t;case B.INFO:return this._clientLogger.info(t)||t;case B.WARN:return this._clientLogger.warn(t)||t;case B.ERROR:return this._clientLogger.error(t)||t;case B.ADVANCED_LOG:return this._advancedLogWriter?this._clientLogger[this._advancedLogWriter](t)||t:""}}},{key:"isLevelEnabled",value:function(e){return e>=this._level}},{key:"hasClientLogger",value:function(){return null!==this._clientLogger}},{key:"getLogger",value:function(e){var t=e.prefix||q;return this._logsDestination===i?this.consoleLoggerWrapper:new W(t)}},{key:"updateLoggerConfig",value:function(e){var t=e||{};this._level=t.level||B.INFO,this._advancedLogWriter="warn",t.advancedLogWriter&&(this._advancedLogWriter=t.advancedLogWriter),t.customizedLogger&&"object"===x(t.customizedLogger)&&(this.useClientLogger=!0),this._clientLogger=t.logger||this.selectLogger(t),this._logsDestination="NULL",t.debug&&(this._logsDestination=i),t.logger&&(this._logsDestination="CLIENT_LOGGER")}},{key:"selectLogger",value:function(e){return e.customizedLogger&&"object"===x(e.customizedLogger)?e.customizedLogger:e.useDefaultLogger?(this.consoleLoggerWrapper=H(),this.consoleLoggerWrapper):null}}]),e}(),V=function(){function e(){M(this,e)}return F(e,[{key:"debug",value:function(){}},{key:"info",value:function(){}},{key:"warn",value:function(){}},{key:"error",value:function(){}},{key:"advancedLog",value:function(){}}]),e}(),W=function(){function e(t){var n;return M(this,e),(n=function(e,t){return!t||"object"!==x(t)&&"function"!=typeof t?function(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}(e):t}(this,P(e).call(this))).prefix=t||q,n}return function(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&D(e,t)}(e,V),F(e,[{key:"debug",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this._log(B.DEBUG,t)}},{key:"info",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this._log(B.INFO,t)}},{key:"warn",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this._log(B.WARN,t)}},{key:"error",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this._log(B.ERROR,t)}},{key:"advancedLog",value:function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return this._log(B.ADVANCED_LOG,t)}},{key:"_shouldLog",value:function(e){return z.hasClientLogger()&&z.isLevelEnabled(e)}},{key:"_writeToClientLogger",value:function(e,t){return z.writeToClientLogger(e,t)}},{key:"_log",value:function(e,t){if(this._shouldLog(e)){var n=z.useClientLogger?t:this._convertToSingleStatement(t,e);return this._writeToClientLogger(e,n)}}},{key:"_convertToSingleStatement",value:function(e,t){var n=new Date(Date.now()).toISOString(),r=this._getLogLevelByValue(t),o="[".concat(n,"][").concat(r,"]");this.prefix&&(o+=this.prefix+" "),this.options&&(this.options.prefix?o+=" "+this.options.prefix+":":o+="",this.options.logMetaData?o+=" Meta data: "+JSON.stringify(this.options.logMetaData):o+="");for(var i=0;i<e.length;i++){var a=e[i];o+=this._convertToString(a)+" "}return o}},{key:"_getLogLevelByValue",value:function(e){switch(e){case 10:return"DEBUG";case 20:return"INFO";case 30:return"WARN";case 40:return"ERROR";case 50:return"ADVANCED_LOG"}}},{key:"_convertToString",value:function(e){try{if(!e)return"";if(N.isString(e))return e;if(N.isObject(e)&&N.isFunction(e.toString)){var t=e.toString();if("[object Object]"!==t)return t}return JSON.stringify(e)}catch(t){return console.error("Error while converting argument to string",e,t),""}}}]),e}(),H=function(){var e=new V;return e.debug=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return console.debug.apply(window.console,[].concat(t))},e.info=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return console.info.apply(window.console,[].concat(t))},e.warn=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return console.warn.apply(window.console,[].concat(t))},e.error=function(){for(var e=arguments.length,t=new Array(e),n=0;n<e;n++)t[n]=arguments[n];return console.error.apply(window.console,[].concat(t))},e},z=new G;function K(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(e,r.key,r)}}var Y=function(){function e(t){var n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:2e3;!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e),this.numAttempts=0,this.executor=t,this.hasActiveReconnection=!1,this.defaultRetry=n}var t,n;return t=e,(n=[{key:"retry",value:function(){var e=this;this.hasActiveReconnection||(this.hasActiveReconnection=!0,setTimeout((function(){e._execute()}),this._getDelay()))}},{key:"_execute",value:function(){this.hasActiveReconnection=!1,this.executor(),this.numAttempts++}},{key:"connected",value:function(){this.numAttempts=0}},{key:"_getDelay",value:function(){var e=Math.pow(2,this.numAttempts)*this.defaultRetry;return e<=3e4?e:3e4}},{key:"getIsConnected",value:function(){return!this.numAttempts}}])&&K(t.prototype,n),e}();r.d(n,"a",(function(){return J}));var X=function(){var e=z.getLogger({prefix:a}),t=N.isNetworkOnline(),n={primary:null,secondary:null},r={reconnectWebSocket:!0,websocketInitFailed:!1,exponentialBackOffTime:1e3,exponentialTimeoutHandle:null,lifeTimeTimeoutHandle:null,webSocketInitCheckerTimeoutId:null,connState:null},o={connectWebSocketRetryCount:0,connectionAttemptStartTime:null,noOpenConnectionsTimestamp:null},i={pendingResponse:!1,intervalHandle:null},O={initFailure:new Set,getWebSocketTransport:null,subscriptionUpdate:new Set,subscriptionFailure:new Set,topic:new Map,allMessage:new Set,connectionGain:new Set,connectionLost:new Set,connectionOpen:new Set,connectionClose:new Set},L={connConfig:null,promiseHandle:null,promiseCompleted:!0},k={subscribed:new Set,pending:new Set,subscriptionHistory:new Set},P={responseCheckIntervalId:null,requestCompleted:!0,reSubscribeIntervalId:null,consecutiveFailedSubscribeAttempts:0,consecutiveNoResponseRequest:0},D=new Y((function(){se()})),x=new Set([A,"aws/unsubscribe",_]),M=setInterval((function(){if(t!==N.isNetworkOnline()){if(!(t=N.isNetworkOnline()))return e.advancedLog(s),void le(e.info(s));var n=V();t&&(!n||q(n,WebSocket.CLOSING)||q(n,WebSocket.CLOSED))&&(e.advancedLog(c),le(e.info(c)),se())}}),250),U=function(t,n){t.forEach((function(t){try{t(n)}catch(t){le(e.error("Error executing callback",t))}}))},F=function(e){if(null===e)return"NULL";switch(e.readyState){case WebSocket.CONNECTING:return"CONNECTING";case WebSocket.OPEN:return"OPEN";case WebSocket.CLOSING:return"CLOSING";case WebSocket.CLOSED:return"CLOSED";default:return"UNDEFINED"}},j=function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:"";le(e.debug("["+t+"] Primary WebSocket: "+F(n.primary)+" | Secondary WebSocket: "+F(n.secondary)))},q=function(e,t){return e&&e.readyState===t},B=function(e){return q(e,WebSocket.OPEN)},G=function(e){return null===e||void 0===e.readyState||q(e,WebSocket.CLOSED)},V=function(){return null!==n.secondary?n.secondary:n.primary},W=function(){return B(V())},H=function(){if(i.pendingResponse)return e.advancedLog(l),le(e.warn(l)),clearInterval(i.intervalHandle),i.pendingResponse=!1,void se();W()?(le(e.debug("Sending heartbeat")),V().send(ie(_)),i.pendingResponse=!0):(e.advancedLog(p),le(e.warn(p)),j("sendHeartBeat"),se())},K=function(){e.advancedLog("Reset Websocket state"),r.exponentialBackOffTime=1e3,i.pendingResponse=!1,r.reconnectWebSocket=!0,clearTimeout(r.lifeTimeTimeoutHandle),clearInterval(i.intervalHandle),clearTimeout(r.exponentialTimeoutHandle),clearTimeout(r.webSocketInitCheckerTimeoutId)},X=function(){P.consecutiveFailedSubscribeAttempts=0,P.consecutiveNoResponseRequest=0,clearInterval(P.responseCheckIntervalId),clearInterval(P.reSubscribeIntervalId)},J=function(){o.connectWebSocketRetryCount=0,o.connectionAttemptStartTime=null,o.noOpenConnectionsTimestamp=null},Q=function(){D.connected();try{e.advancedLog(d),le(e.info(d)),j("webSocketOnOpen"),null!==r.connState&&r.connState!==R||U(O.connectionGain),r.connState="connected";var t=Date.now();U(O.connectionOpen,{connectWebSocketRetryCount:o.connectWebSocketRetryCount,connectionAttemptStartTime:o.connectionAttemptStartTime,noOpenConnectionsTimestamp:o.noOpenConnectionsTimestamp,connectionEstablishedTime:t,timeToConnect:t-o.connectionAttemptStartTime,timeWithoutConnection:o.noOpenConnectionsTimestamp?t-o.noOpenConnectionsTimestamp:null}),J(),K(),V().openTimestamp=Date.now(),0===k.subscribed.size&&B(n.secondary)&&te(n.primary,"[Primary WebSocket] Closing WebSocket"),(k.subscribed.size>0||k.pending.size>0)&&(B(n.secondary)&&le(e.info("Subscribing secondary websocket to topics of primary websocket")),k.subscribed.forEach((function(e){k.subscriptionHistory.add(e),k.pending.add(e)})),k.subscribed.clear(),ee()),H(),i.intervalHandle=setInterval(H,1e4);var a=1e3*L.connConfig.webSocketTransport.transportLifeTimeInSeconds;le(e.debug("Scheduling WebSocket manager reconnection, after delay "+a+" ms")),r.lifeTimeTimeoutHandle=setTimeout((function(){le(e.debug("Starting scheduled WebSocket manager reconnection")),se()}),a)}catch(t){le(e.error("Error after establishing WebSocket connection",t))}},Z=function(t){j("webSocketOnError"),e.advancedLog(h,JSON.stringify(t)),le(e.error(h,JSON.stringify(t))),D.getIsConnected()?se():D.retry()},$=function(t){var r=JSON.parse(t.data);switch(r.topic){case A:if(le(e.debug("Subscription Message received from webSocket server",t.data)),P.requestCompleted=!0,P.consecutiveNoResponseRequest=0,"success"===r.content.status)P.consecutiveFailedSubscribeAttempts=0,r.content.topics.forEach((function(e){k.subscriptionHistory.delete(e),k.pending.delete(e),k.subscribed.add(e)})),0===k.subscriptionHistory.size?B(n.secondary)&&(le(e.info("Successfully subscribed secondary websocket to all topics of primary websocket")),te(n.primary,"[Primary WebSocket] Closing WebSocket")):ee(),U(O.subscriptionUpdate,r);else{if(clearInterval(P.reSubscribeIntervalId),++P.consecutiveFailedSubscribeAttempts,5===P.consecutiveFailedSubscribeAttempts)return U(O.subscriptionFailure,r),void(P.consecutiveFailedSubscribeAttempts=0);P.reSubscribeIntervalId=setInterval((function(){ee()}),500)}break;case _:le(e.debug("Heartbeat response received")),i.pendingResponse=!1;break;default:if(r.topic){if(e.advancedLog(I,r.topic),le(e.debug(I+r.topic)),B(n.primary)&&B(n.secondary)&&0===k.subscriptionHistory.size&&this===n.primary)return void le(e.warn("Ignoring Message for Topic "+r.topic+", to avoid duplicates"));if(0===O.allMessage.size&&0===O.topic.size)return void le(e.warn("No registered callback listener for Topic",r.topic));e.advancedLog("WebsocketManager invoke callbacks for topic success ",r.topic),U(O.allMessage,r),O.topic.has(r.topic)&&U(O.topic.get(r.topic),r)}else r.message?(e.advancedLog(T,r),le(e.warn(T,r))):(e.advancedLog(w,r),le(e.warn(w,r)))}},ee=function t(){if(P.consecutiveNoResponseRequest>3)return le(e.warn("Ignoring subscribePendingTopics since we have exhausted max subscription retries with no response")),void U(O.subscriptionFailure,N.getSubscriptionResponse(A,!1,Array.from(k.pending)));W()?0!==Array.from(k.pending).length&&(clearInterval(P.responseCheckIntervalId),V().send(ie(A,{topics:Array.from(k.pending)})),P.requestCompleted=!1,P.responseCheckIntervalId=setInterval((function(){P.requestCompleted||(++P.consecutiveNoResponseRequest,t())}),1e3)):le(e.warn("Ignoring subscribePendingTopics call since Default WebSocket is not open"))},te=function(t,n){q(t,WebSocket.CONNECTING)||q(t,WebSocket.OPEN)?t.close(1e3,n):le(e.warn("Ignoring WebSocket Close request, WebSocket State: "+F(t)))},ne=function(e){te(n.primary,"[Primary] WebSocket "+e),te(n.secondary,"[Secondary] WebSocket "+e)},re=function(){o.connectWebSocketRetryCount++;var t=N.addJitter(r.exponentialBackOffTime,.3);Date.now()+t<=L.connConfig.urlConnValidTime?(e.advancedLog(g),le(e.debug(g+t+" ms")),r.exponentialTimeoutHandle=setTimeout((function(){return ce()}),t),r.exponentialBackOffTime*=2):(e.advancedLog(m),le(e.warn(m)),se())},oe=function(t){K(),X(),e.advancedLog(v,t),le(e.error(v)),r.websocketInitFailed=!0,ne("Terminating WebSocket Manager"),clearInterval(M),U(O.initFailure,{connectWebSocketRetryCount:o.connectWebSocketRetryCount,connectionAttemptStartTime:o.connectionAttemptStartTime,reason:t}),J()},ie=function(e,t){return JSON.stringify({topic:e,content:t})},ae=function(t){return!!(N.isObject(t)&&N.isObject(t.webSocketTransport)&&N.isNonEmptyString(t.webSocketTransport.url)&&N.validWSUrl(t.webSocketTransport.url)&&1e3*t.webSocketTransport.transportLifeTimeInSeconds>=3e5)||(le(e.error("Invalid WebSocket Connection Configuration",t)),!1)},se=function(){if(!N.isNetworkOnline())return e.advancedLog(u),void le(e.info(u));if(r.websocketInitFailed)le(e.debug("WebSocket Init had failed, ignoring this getWebSocketConnConfig request"));else{if(L.promiseCompleted)return K(),e.advancedLog(y),le(e.info(y)),o.connectionAttemptStartTime=o.connectionAttemptStartTime||Date.now(),L.promiseCompleted=!1,L.promiseHandle=O.getWebSocketTransport(),L.promiseHandle.then((function(t){return L.promiseCompleted=!0,e.advancedLog(b),le(e.debug(b,t)),ae(t)?(L.connConfig=t,L.connConfig.urlConnValidTime=Date.now()+85e3,ce()):(oe("Invalid WebSocket connection configuration: "+t),{webSocketConnectionFailed:!0})}),(function(t){return L.promiseCompleted=!0,e.advancedLog(E),le(e.error(E,t)),N.isNetworkFailure(t)?(e.advancedLog(S+JSON.stringify(t)),le(e.info(S+JSON.stringify(t))),D.retry()):oe("Failed to fetch webSocket connection configuration: "+JSON.stringify(t)),{webSocketConnectionFailed:!0}}));le(e.debug("There is an ongoing getWebSocketConnConfig request, this request will be ignored"))}},ce=function(){if(r.websocketInitFailed)return le(e.info("web-socket initializing had failed, aborting re-init")),{webSocketConnectionFailed:!0};if(!N.isNetworkOnline())return le(e.warn("System is offline aborting web-socket init")),{webSocketConnectionFailed:!0};e.advancedLog(C),le(e.info(C)),j("initWebSocket");try{if(ae(L.connConfig)){var t=null;return B(n.primary)?(le(e.debug("Primary Socket connection is already open")),q(n.secondary,WebSocket.CONNECTING)||(le(e.debug("Establishing a secondary web-socket connection")),D.numAttempts=0,n.secondary=ue()),t=n.secondary):(q(n.primary,WebSocket.CONNECTING)||(le(e.debug("Establishing a primary web-socket connection")),n.primary=ue()),t=n.primary),r.webSocketInitCheckerTimeoutId=setTimeout((function(){B(t)||re()}),1e3),{webSocketConnectionFailed:!1}}}catch(t){return le(e.error("Error Initializing web-socket-manager",t)),oe("Failed to initialize new WebSocket: "+t.message),{webSocketConnectionFailed:!0}}},ue=function(){var t=new WebSocket(L.connConfig.webSocketTransport.url);return t.addEventListener("open",Q),t.addEventListener("message",$),t.addEventListener("error",Z),t.addEventListener("close",(function(i){return function(t,i){e.advancedLog(f,JSON.stringify(t)),le(e.info(f,JSON.stringify(t))),j("webSocketOnClose before-cleanup"),U(O.connectionClose,{openTimestamp:i.openTimestamp,closeTimestamp:Date.now(),connectionDuration:Date.now()-i.openTimestamp,code:t.code,reason:t.reason}),G(n.primary)&&(n.primary=null),G(n.secondary)&&(n.secondary=null),r.reconnectWebSocket&&(B(n.primary)||B(n.secondary)?G(n.primary)&&B(n.secondary)&&(le(e.info("[Primary] WebSocket Cleanly Closed")),n.primary=n.secondary,n.secondary=null):(le(e.warn("Neither primary websocket and nor secondary websocket have open connections, attempting to re-establish connection")),r.connState===R?le(e.info("Ignoring connectionLost callback invocation")):(U(O.connectionLost,{openTimestamp:i.openTimestamp,closeTimestamp:Date.now(),connectionDuration:Date.now()-i.openTimestamp,code:t.code,reason:t.reason}),o.noOpenConnectionsTimestamp=Date.now()),r.connState=R,se()),j("webSocketOnClose after-cleanup"))}(i,t)})),t},le=function(e){return e&&"function"==typeof e.sendInternalLogToServer&&e.sendInternalLogToServer(),e};this.init=function(t){if(N.assertTrue(N.isFunction(t),"transportHandle must be a function"),null===O.getWebSocketTransport)return O.getWebSocketTransport=t,se();le(e.warn("Web Socket Manager was already initialized"))},this.onInitFailure=function(t){return e.advancedLog("Initializing Websocket Manager Failed!"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.initFailure.add(t),r.websocketInitFailed&&t(),function(){return O.initFailure.delete(t)}},this.onConnectionOpen=function(t){return e.advancedLog("Websocket connection open"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.connectionOpen.add(t),function(){return O.connectionOpen.delete(t)}},this.onConnectionClose=function(t){return e.advancedLog("Websocket connection close"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.connectionClose.add(t),function(){return O.connectionClose.delete(t)}},this.onConnectionGain=function(t){return e.advancedLog("Websocket connection gain"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.connectionGain.add(t),W()&&t(),function(){return O.connectionGain.delete(t)}},this.onConnectionLost=function(t){return e.advancedLog("Websocket connection lost"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.connectionLost.add(t),r.connState===R&&t(),function(){return O.connectionLost.delete(t)}},this.onSubscriptionUpdate=function(e){return N.assertTrue(N.isFunction(e),"cb must be a function"),O.subscriptionUpdate.add(e),function(){return O.subscriptionUpdate.delete(e)}},this.onSubscriptionFailure=function(t){return e.advancedLog("Websocket subscription failure"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.subscriptionFailure.add(t),function(){return O.subscriptionFailure.delete(t)}},this.onMessage=function(e,t){return N.assertNotNull(e,"topicName"),N.assertTrue(N.isFunction(t),"cb must be a function"),O.topic.has(e)?O.topic.get(e).add(t):O.topic.set(e,new Set([t])),function(){return O.topic.get(e).delete(t)}},this.onAllMessage=function(e){return N.assertTrue(N.isFunction(e),"cb must be a function"),O.allMessage.add(e),function(){return O.allMessage.delete(e)}},this.subscribeTopics=function(e){N.assertNotNull(e,"topics"),N.assertIsList(e),e.forEach((function(e){k.subscribed.has(e)||k.pending.add(e)})),P.consecutiveNoResponseRequest=0,ee()},this.sendMessage=function(t){if(N.assertIsObject(t,"payload"),void 0===t.topic||x.has(t.topic))le(e.warn("Cannot send message, Invalid topic",t));else{try{t=JSON.stringify(t)}catch(n){return void le(e.warn("Error stringify message",t))}W()?V().send(t):le(e.warn("Cannot send message, web socket connection is not open"))}},this.closeWebSocket=function(){K(),X(),r.reconnectWebSocket=!1,clearInterval(M),ne("User request to close WebSocket")},this.terminateWebSocketManager=oe},J={create:function(){return new X},setGlobalConfig:function(e){var t=e&&e.loggerConfig;z.updateLoggerConfig(t)},LogLevel:B,Logger:j}},function(t,n,r){var o;!function(){"use strict";var i={not_string:/[^s]/,not_bool:/[^t]/,not_type:/[^T]/,not_primitive:/[^v]/,number:/[diefg]/,numeric_arg:/[bcdiefguxX]/,json:/[j]/,not_json:/[^j]/,text:/^[^\x25]+/,modulo:/^\x25{2}/,placeholder:/^\x25(?:([1-9]\d*)\$|\(([^)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,key:/^([a-z_][a-z_\d]*)/i,key_access:/^\.([a-z_][a-z_\d]*)/i,index_access:/^\[(\d+)\]/,sign:/^[+-]/};function a(t){return function(t,n){var r,o,s,c,u,l,p,d,f,h=1,g=t.length,m="";for(o=0;o<g;o++)if("string"==typeof t[o])m+=t[o];else if("object"==e(t[o])){if((c=t[o]).keys)for(r=n[h],s=0;s<c.keys.length;s++){if(null==r)throw new Error(a('[sprintf] Cannot access property "%s" of undefined value "%s"',c.keys[s],c.keys[s-1]));r=r[c.keys[s]]}else r=c.param_no?n[c.param_no]:n[h++];if(i.not_type.test(c.type)&&i.not_primitive.test(c.type)&&r instanceof Function&&(r=r()),i.numeric_arg.test(c.type)&&"number"!=typeof r&&isNaN(r))throw new TypeError(a("[sprintf] expecting number but found %T",r));switch(i.number.test(c.type)&&(d=r>=0),c.type){case"b":r=parseInt(r,10).toString(2);break;case"c":r=String.fromCharCode(parseInt(r,10));break;case"d":case"i":r=parseInt(r,10);break;case"j":r=JSON.stringify(r,null,c.width?parseInt(c.width):0);break;case"e":r=c.precision?parseFloat(r).toExponential(c.precision):parseFloat(r).toExponential();break;case"f":r=c.precision?parseFloat(r).toFixed(c.precision):parseFloat(r);break;case"g":r=c.precision?String(Number(r.toPrecision(c.precision))):parseFloat(r);break;case"o":r=(parseInt(r,10)>>>0).toString(8);break;case"s":r=String(r),r=c.precision?r.substring(0,c.precision):r;break;case"t":r=String(!!r),r=c.precision?r.substring(0,c.precision):r;break;case"T":r=Object.prototype.toString.call(r).slice(8,-1).toLowerCase(),r=c.precision?r.substring(0,c.precision):r;break;case"u":r=parseInt(r,10)>>>0;break;case"v":r=r.valueOf(),r=c.precision?r.substring(0,c.precision):r;break;case"x":r=(parseInt(r,10)>>>0).toString(16);break;case"X":r=(parseInt(r,10)>>>0).toString(16).toUpperCase()}i.json.test(c.type)?m+=r:(!i.number.test(c.type)||d&&!c.sign?f="":(f=d?"+":"-",r=r.toString().replace(i.sign,"")),l=c.pad_char?"0"===c.pad_char?"0":c.pad_char.charAt(1):" ",p=c.width-(f+r).length,u=c.width&&p>0?l.repeat(p):"",m+=c.align?f+r+u:"0"===l?f+u+r:u+f+r)}return m}(function(e){if(c[e])return c[e];for(var t,n=e,r=[],o=0;n;){if(null!==(t=i.text.exec(n)))r.push(t[0]);else if(null!==(t=i.modulo.exec(n)))r.push("%");else{if(null===(t=i.placeholder.exec(n)))throw new SyntaxError("[sprintf] unexpected placeholder");if(t[2]){o|=1;var a=[],s=t[2],u=[];if(null===(u=i.key.exec(s)))throw new SyntaxError("[sprintf] failed to parse named argument key");for(a.push(u[1]);""!==(s=s.substring(u[0].length));)if(null!==(u=i.key_access.exec(s)))a.push(u[1]);else{if(null===(u=i.index_access.exec(s)))throw new SyntaxError("[sprintf] failed to parse named argument key");a.push(u[1])}t[2]=a}else o|=2;if(3===o)throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");r.push({placeholder:t[0],param_no:t[1],keys:t[2],sign:t[3],pad_char:t[4],align:t[5],width:t[6],precision:t[7],type:t[8]})}n=n.substring(t[0].length)}return c[e]=r}(t),arguments)}function s(e,t){return a.apply(null,[e].concat(t||[]))}var c=Object.create(null);n.sprintf=a,n.vsprintf=s,"undefined"!=typeof window&&(window.sprintf=a,window.vsprintf=s,void 0===(o=function(){return{sprintf:a,vsprintf:s}}.call(n,r,n,t))||(t.exports=o))}()},function(e,t,n){"use strict";n.r(t),function(e){n.d(t,"WebSocketManager",(function(){return o}));var r=n(0);e.connect=e.connect||{},connect.WebSocketManager=r.a;var o=r.a}.call(this,n(3))},function(t,n){var r;r=function(){return this}();try{r=r||new Function("return this")()}catch(t){"object"==("undefined"==typeof window?"undefined":e(window))&&(r=window)}t.exports=r}])},144:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}!function(){var t=this||globalThis,n=t.connect||{};t.connect=n,t.lily=n;var r={TEST:"TEST",TRACE:"TRACE",DEBUG:"DEBUG",INFO:"INFO",LOG:"LOG",WARN:"WARN",ERROR:"ERROR",CRITICAL:"CRITICAL"},o={CCP:"ccp",SOFTPHONE:"softphone",CHAT:"chat",TASK:"task"},i={TEST:0,TRACE:10,DEBUG:20,INFO:30,LOG:40,WARN:50,ERROR:100,CRITICAL:200},a="CCP",s="SharedWorker",c="CRM",u={TRACE:function(e){console.info(e)},DEBUG:function(e){console.info(e)},INFO:function(e){console.info(e)},LOG:function(e){console.log(e)},TEST:function(e){console.log(e)},WARN:function(e){console.warn(e)},ERROR:function(e){console.error(e)},CRITICAL:function(e){console.error(e)}},l=function(e){var t,n,r=Array.prototype.slice.call(e,0),i=r.shift();return function(e){return-1!==Object.values(o).indexOf(e)}(i)?(n=i,t=r.shift()):(t=i,n=o.CCP),{format:t,component:n,args:r}},p=function(e,t,r,o,i,u){this.component=e,this.level=t,this.text=r,this.time=new Date,this.tabId=null===i?null:i||n.core.tabId,this.exception=null,this.objects=[],this.line=0,this.agentResourceId=null;try{n.agent.initialized&&(this.agentResourceId=(new n.Agent)._getResourceId())}catch(e){console.log("Issue finding agentResourceId: ",e)}this.loggerId=o,u?this.contextLayer=u:n.isSharedWorker()?this.contextLayer=s:n.isCRM()?this.contextLayer=c:n.isCCP()&&(this.contextLayer=a)};p.fromObject=function(e){var t=e.tabId||null,n=e.contextLayer||null,r=new p(o.CCP,e.level,e.text,e.loggerId,t,n);return"[object Date]"===Object.prototype.toString.call(e.time)?r.time=new Date(e.time.getTime()):"number"==typeof e.time?r.time=new Date(e.time):"string"==typeof e.time?r.time=Date.parse(e.time):r.time=new Date,r.exception=e.exception,r.objects=e.objects,r};var d=function(t){var n=/(AuthToken.*)/gi;t&&"object"===e(t)&&Object.keys(t).forEach((function(r){"object"===e(t[r])?d(t[r]):"string"==typeof t[r]&&("url"===r||"text"===r?t[r]=t[r].replace(n,"[redacted]"):["quickConnectName"].includes(r)?t[r]="[redacted]":["customerId","CustomerId","SpeakerId","CustomerSpeakerId"].includes(r)&&(t[r]="".concat("[obfuscated value]"," ").concat(md5(t[r]))))}))},f=function(t){if(this.type=t instanceof Error?t.name:t.code||Object.prototype.toString.call(t),this.message=t.message,this.stack=[],t.stack)try{Array.isArray(t.stack)?this.stack=t.stack:"object"===e(t.stack)?this.stack=[JSON.stringify(t.stack)]:"string"==typeof t.stack&&(this.stack=t.stack.split("\n"))}catch(e){}};p.prototype.toString=function(){return n.sprintf("[%s] [%s] [%s]: %s",this.getTime()&&this.getTime().toISOString?this.getTime().toISOString():"???",this.getLevel(),this.getAgentResourceId(),this.getText())},p.prototype.getTime=function(){return this.time},p.prototype.getAgentResourceId=function(){return this.agentResourceId},p.prototype.getTabId=function(){return this.tabId},p.prototype.getContextLayer=function(){return this.contextLayer},p.prototype.getLevel=function(){return this.level},p.prototype.getText=function(){return this.text},p.prototype.getComponent=function(){return this.component},p.prototype.withException=function(e){return this.exception=new f(e),this},p.prototype.withObject=function(e){var t=n.deepcopy(e);return d(t),this.objects.push(t),this},p.prototype.withCrossOriginEventObject=function(e){var t=n.deepcopyCrossOriginEvent(e);return d(t),this.objects.push(t),this},p.prototype.sendInternalLogToServer=function(){return n.getLog()._serverBoundInternalLogs.push(this),this};var h=function(){this._logs=[],this._rolledLogs=[],this._logsToPush=[],this._serverBoundInternalLogs=[],this._echoLevel=i.INFO,this._logLevel=i.INFO,this._lineCount=0,this._logRollInterval=0,this._logRollTimer=null,this._loggerId=(new Date).getTime()+"-"+Math.random().toString(36).slice(2),this.setLogRollInterval(18e5),this._startLogIndexToPush=0};h.prototype.setLogRollInterval=function(e){var n=this;this._logRollTimer&&e===this._logRollInterval?this.warn("Logger is already set to the given interval: %d",this._logRollInterval):(this._logRollTimer&&t.clearInterval(this._logRollTimer),this._logRollInterval=e,this._logRollTimer=t.setInterval((function(){n._rolledLogs=n._logs,n._logs=[],n._startLogIndexToPush=0,n.info("Log roll interval occurred.")}),this._logRollInterval))},h.prototype.setLogLevel=function(e){if(!(e in i))throw new Error("Unknown logging level: "+e);this._logLevel=i[e]},h.prototype.setEchoLevel=function(e){if(!(e in i))throw new Error("Unknown logging level: "+e);this._echoLevel=i[e]},h.prototype.write=function(e,t,n){var r=new p(e,t,n,this.getLoggerId());return d(r),this.addLogEntry(r),r},h.prototype.addLogEntry=function(e){d(e),this._logs.push(e),o.SOFTPHONE===e.component&&this._logsToPush.push(e),e.level in i&&i[e.level]>=this._logLevel&&(i[e.level]>=this._echoLevel&&u[e.getLevel()](e.toString()),e.line=this._lineCount++)},h.prototype.sendInternalLogEntryToServer=function(e){this._serverBoundInternalLogs.push(e),e.level in i&&i[e.level]>=this._logLevel&&(i[e.level]>=this._echoLevel&&u[e.getLevel()](e.toString()),e.line=this._lineCount++)},h.prototype.clearObjects=function(){for(var e=0;e<this._logs.length;e++)this._logs[e].objects&&delete this._logs[e].objects},h.prototype.clearExceptions=function(){for(var e=0;e<this._logs.length;e++)this._logs[e].exception&&delete this._logs[e].exception},h.prototype.trace=function(){var e=l(arguments);return this.write(e.component,r.TRACE,n.vsprintf(e.format,e.args))},h.prototype.debug=function(){var e=l(arguments);return this.write(e.component,r.DEBUG,n.vsprintf(e.format,e.args))},h.prototype.info=function(){var e=l(arguments);return this.write(e.component,r.INFO,n.vsprintf(e.format,e.args))},h.prototype.log=function(){var e=l(arguments);return this.write(e.component,r.LOG,n.vsprintf(e.format,e.args))},h.prototype.test=function(){var e=l(arguments);return this.write(e.component,r.TEST,n.vsprintf(e.format,e.args))},h.prototype.warn=function(){var e=l(arguments);return this.write(e.component,r.WARN,n.vsprintf(e.format,e.args))},h.prototype.error=function(){var e=l(arguments);return this.write(e.component,r.ERROR,n.vsprintf(e.format,e.args))},h.prototype.critical=function(){var e=l(arguments);return this.write(e.component,r.ERROR,n.vsprintf(e.format,e.args))},h.prototype.toString=function(){for(var e=[],t=0;t<this._logs.length;t++)e.push(this._logs[t].toString());return e.join("\n")},h.prototype.download=function(r){var o,a="agent-log",s=!1,c=!0===(null===(o=n)||void 0===o||null===(o=o.globalResiliency)||void 0===o?void 0:o.globalResiliencyEnabled);"object"===e(r)&&null!==r?(a=r.logName||a,s=r.filterByLogLevel||s):"string"==typeof r&&(a=r||a),c&&(n.globalResiliency._downloadCCPLogs(),a="crm-"+a);var u=this,l=this._rolledLogs.concat(this._logs);s&&(l=l.filter((function(e){return i[e.level]>=u._logLevel})));var p=new t.Blob([JSON.stringify(l,void 0,4)],["text/plain"]),d=document.createElement("a");a=a||"agent-log",d.href=t.URL.createObjectURL(p),d.download=a+".txt",document.body.appendChild(d),d.click(),document.body.removeChild(d)},h.prototype.scheduleUpstreamLogPush=function(e){n.upstreamLogPushScheduled||(n.upstreamLogPushScheduled=!0,t.setInterval(n.hitch(this,this.reportMasterLogsUpStream,e),5e3))},h.prototype.reportMasterLogsUpStream=function(e){var t=this._logsToPush.slice();this._logsToPush=[],n.ifMaster(n.MasterTopics.SEND_LOGS,(function(){t.length>0&&e.sendUpstream(n.EventType.SEND_LOGS,t)}))},h.prototype.scheduleUpstreamOuterContextCCPserverBoundLogsPush=function(e){t.setInterval(n.hitch(this,this.pushOuterContextCCPserverBoundLogsUpstream,e),1e3)},h.prototype.scheduleUpstreamOuterContextCCPLogsPush=function(e){t.setInterval(n.hitch(this,this.pushOuterContextCCPLogsUpstream,e),1e3)},h.prototype.pushOuterContextCCPserverBoundLogsUpstream=function(e){if(this._serverBoundInternalLogs.length>0){for(var t=0;t<this._serverBoundInternalLogs.length;t++)this._serverBoundInternalLogs[t].text=this._serverBoundInternalLogs[t].text;e.sendUpstream(n.EventType.SERVER_BOUND_INTERNAL_LOG,this._serverBoundInternalLogs),this._serverBoundInternalLogs=[]}},h.prototype.pushOuterContextCCPLogsUpstream=function(e){for(var t=this._startLogIndexToPush;t<this._logs.length;t++)this._logs[t].loggerId===this._loggerId&&e.sendUpstream(n.EventType.LOG,this._logs[t]);this._startLogIndexToPush=this._logs.length},h.prototype.getLoggerId=function(){return this._loggerId},h.prototype.scheduleDownstreamClientSideLogsPush=function(){t.setInterval(n.hitch(this,this.pushClientSideLogsDownstream),5e3)},h.prototype.pushClientSideLogsDownstream=function(){var e=[];this._serverBoundInternalLogs.length<50||(this._serverBoundInternalLogs.length>500?e=this._serverBoundInternalLogs.splice(0,500):(e=this._serverBoundInternalLogs,this._serverBoundInternalLogs=[]),n.publishClientSideLogs(e))};var g=function(e){h.call(this),this.conduit=e,t.setInterval(n.hitch(this,this._pushLogsDownstream),g.LOG_PUSH_INTERVAL),t.clearInterval(this._logRollTimer),this._logRollTimer=null};g.LOG_PUSH_INTERVAL=1e3,g.prototype=Object.create(h.prototype),g.prototype.constructor=g,g.prototype.pushLogsDownstream=function(e){var t=this;e.forEach((function(e){t.conduit.sendDownstream(n.EventType.LOG,e)}))},g.prototype._pushLogsDownstream=function(){var e=this;this._logs.forEach((function(t){e.conduit.sendDownstream(n.EventType.LOG,t)})),this._logs=[];for(var t=0;t<this._serverBoundInternalLogs.length;t++)this.conduit.sendDownstream(n.EventType.SERVER_BOUND_INTERNAL_LOG,this._serverBoundInternalLogs[t]);this._serverBoundInternalLogs=[]};var m=function(e){return function(){try{return e.apply(this,arguments)}catch(e){u.ERROR(e)}}};n.rootLogger=new h,function(e){for(var t in e)"function"==typeof e[t]&&(e[t]=m(e[t]))}(n.rootLogger),(n=n||{}).getLog=function(){return n.rootLogger},n.LogEntry=p,n.Logger=h,n.LogLevel=r,n.LogComponent=o,n.DownstreamConduitLogger=g}()},254:function(){!function(){function e(e,t){var n=(65535&e)+(65535&t);return(e>>16)+(t>>16)+(n>>16)<<16|65535&n}function t(t,n,r,o,i,a){return e((s=e(e(n,t),e(o,a)))<<(c=i)|s>>>32-c,r);var s,c}function n(e,n,r,o,i,a,s){return t(n&r|~n&o,e,n,i,a,s)}function r(e,n,r,o,i,a,s){return t(n&o|r&~o,e,n,i,a,s)}function o(e,n,r,o,i,a,s){return t(n^r^o,e,n,i,a,s)}function i(e,n,r,o,i,a,s){return t(r^(n|~o),e,n,i,a,s)}function a(t,a){var s,c,u,l,p;t[a>>5]|=128<<a%32,t[14+(a+64>>>9<<4)]=a;var d=1732584193,f=-271733879,h=-1732584194,g=271733878;for(s=0;s<t.length;s+=16)c=d,u=f,l=h,p=g,d=n(d,f,h,g,t[s],7,-680876936),g=n(g,d,f,h,t[s+1],12,-389564586),h=n(h,g,d,f,t[s+2],17,606105819),f=n(f,h,g,d,t[s+3],22,-1044525330),d=n(d,f,h,g,t[s+4],7,-176418897),g=n(g,d,f,h,t[s+5],12,1200080426),h=n(h,g,d,f,t[s+6],17,-1473231341),f=n(f,h,g,d,t[s+7],22,-45705983),d=n(d,f,h,g,t[s+8],7,1770035416),g=n(g,d,f,h,t[s+9],12,-1958414417),h=n(h,g,d,f,t[s+10],17,-42063),f=n(f,h,g,d,t[s+11],22,-1990404162),d=n(d,f,h,g,t[s+12],7,1804603682),g=n(g,d,f,h,t[s+13],12,-40341101),h=n(h,g,d,f,t[s+14],17,-1502002290),d=r(d,f=n(f,h,g,d,t[s+15],22,1236535329),h,g,t[s+1],5,-165796510),g=r(g,d,f,h,t[s+6],9,-1069501632),h=r(h,g,d,f,t[s+11],14,643717713),f=r(f,h,g,d,t[s],20,-373897302),d=r(d,f,h,g,t[s+5],5,-701558691),g=r(g,d,f,h,t[s+10],9,38016083),h=r(h,g,d,f,t[s+15],14,-660478335),f=r(f,h,g,d,t[s+4],20,-405537848),d=r(d,f,h,g,t[s+9],5,568446438),g=r(g,d,f,h,t[s+14],9,-1019803690),h=r(h,g,d,f,t[s+3],14,-187363961),f=r(f,h,g,d,t[s+8],20,1163531501),d=r(d,f,h,g,t[s+13],5,-1444681467),g=r(g,d,f,h,t[s+2],9,-51403784),h=r(h,g,d,f,t[s+7],14,1735328473),d=o(d,f=r(f,h,g,d,t[s+12],20,-1926607734),h,g,t[s+5],4,-378558),g=o(g,d,f,h,t[s+8],11,-2022574463),h=o(h,g,d,f,t[s+11],16,1839030562),f=o(f,h,g,d,t[s+14],23,-35309556),d=o(d,f,h,g,t[s+1],4,-1530992060),g=o(g,d,f,h,t[s+4],11,1272893353),h=o(h,g,d,f,t[s+7],16,-155497632),f=o(f,h,g,d,t[s+10],23,-1094730640),d=o(d,f,h,g,t[s+13],4,681279174),g=o(g,d,f,h,t[s],11,-358537222),h=o(h,g,d,f,t[s+3],16,-722521979),f=o(f,h,g,d,t[s+6],23,76029189),d=o(d,f,h,g,t[s+9],4,-640364487),g=o(g,d,f,h,t[s+12],11,-421815835),h=o(h,g,d,f,t[s+15],16,530742520),d=i(d,f=o(f,h,g,d,t[s+2],23,-995338651),h,g,t[s],6,-198630844),g=i(g,d,f,h,t[s+7],10,1126891415),h=i(h,g,d,f,t[s+14],15,-1416354905),f=i(f,h,g,d,t[s+5],21,-57434055),d=i(d,f,h,g,t[s+12],6,1700485571),g=i(g,d,f,h,t[s+3],10,-1894986606),h=i(h,g,d,f,t[s+10],15,-1051523),f=i(f,h,g,d,t[s+1],21,-2054922799),d=i(d,f,h,g,t[s+8],6,1873313359),g=i(g,d,f,h,t[s+15],10,-30611744),h=i(h,g,d,f,t[s+6],15,-1560198380),f=i(f,h,g,d,t[s+13],21,1309151649),d=i(d,f,h,g,t[s+4],6,-145523070),g=i(g,d,f,h,t[s+11],10,-1120210379),h=i(h,g,d,f,t[s+2],15,718787259),f=i(f,h,g,d,t[s+9],21,-343485551),d=e(d,c),f=e(f,u),h=e(h,l),g=e(g,p);return[d,f,h,g]}function s(e){var t,n="",r=32*e.length;for(t=0;t<r;t+=8)n+=String.fromCharCode(e[t>>5]>>>t%32&255);return n}function c(e){var t,n=[];for(n[(e.length>>2)-1]=void 0,t=0;t<n.length;t+=1)n[t]=0;var r=8*e.length;for(t=0;t<r;t+=8)n[t>>5]|=(255&e.charCodeAt(t/8))<<t%32;return n}function u(e){var t,n,r="0123456789abcdef",o="";for(n=0;n<e.length;n+=1)t=e.charCodeAt(n),o+=r.charAt(t>>>4&15)+r.charAt(15&t);return o}function l(e){return unescape(encodeURIComponent(e))}function p(e){return function(e){return s(a(c(e),8*e.length))}(l(e))}function d(e,t){return function(e,t){var n,r,o=c(e),i=[],u=[];for(i[15]=u[15]=void 0,o.length>16&&(o=a(o,8*e.length)),n=0;n<16;n+=1)i[n]=909522486^o[n],u[n]=1549556828^o[n];return r=a(i.concat(c(t)),512+8*t.length),s(a(u.concat(r),640))}(l(e),l(t))}(this||globalThis).md5=function(e,t,n){return t?n?d(t,e):u(d(t,e)):n?p(e):u(p(e))}}()},142:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,t.ChatMediaController=function(e,n){var r=t.getLog(),o=t.LogComponent.CHAT,i=function(n,r){t.publishMetric({name:n,contactId:e.contactId,data:r||e})},a=function(e){e.onConnectionBroken((function(e){r.error(o,"Chat Session connection broken").withException(e).sendInternalLogToServer(),i("Chat Session connection broken",e)})),e.onConnectionEstablished((function(e){r.info(o,"Chat Session connection established").withObject(e).sendInternalLogToServer(),i("Chat Session connection established",e)}))};return{get:function(){return function(){i("Chat media controller init",e.contactId),r.info(o,"Chat media controller init").withObject(e).sendInternalLogToServer(),t.ChatSession.setGlobalConfig({loggerConfig:{logger:r},region:n.region});var s=t.ChatSession.create({chatDetails:e,type:"AGENT",websocketManager:t.core.getWebSocketManager()});return a(s),s.connect().then((function(t){return r.info(o,"Chat Session Successfully established for contactId %s",e.contactId).sendInternalLogToServer(),i("Chat Session Successfully established",e.contactId),s})).catch((function(t){throw r.error(o,"Chat Session establishement failed for contact %s",e.contactId).withException(t).sendInternalLogToServer(),i("Chat Session establishement failed",e.contactId,t),t}))}()}}}}()},884:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,t.MediaFactory=function(e){var n={},r=new Set,o=t.getLog(),i=t.LogComponent.CHAT,a=t.merge({},e)||{};a.region=a.region||"us-west-2";var s=function(e){n[e]&&!r.has(e)&&(o.info(i,"Destroying mediaController for %s",e),r.add(e),n[e].then((function(t){"function"==typeof t.cleanUp&&t.cleanUp(),delete n[e],r.delete(e)})).catch((function(){delete n[e],r.delete(e)})))};return{get:function(e){return function(e){return e.isActive()}(e)?function(e){var r=e.getConnectionId();if(!e.getMediaInfo())return o.error(i,"Media info does not exist for a media type %s",e.getMediaType()).withObject(e).sendInternalLogToServer(),Promise.reject("Media info does not exist for this connection");if(n[r])return n[r];switch(o.info(i,"media controller of type %s init",e.getMediaType()).withObject(e).sendInternalLogToServer(),e.getMediaType()){case t.MediaType.CHAT:return n[r]=new t.ChatMediaController(e.getMediaInfo(),a).get();case t.MediaType.SOFTPHONE:return n[r]=new t.SoftphoneMediaController(e.getMediaInfo()).get();case t.MediaType.TASK:return n[r]=new t.TaskMediaController(e.getMediaInfo()).get();default:return o.error(i,"Unrecognized media type %s ",e.getMediaType()).sendInternalLogToServer(),Promise.reject()}}(e):(s(e.getConnectionId()),Promise.reject("Media Controller is no longer available for this connection"))},destroy:s}}}()},390:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,t.SoftphoneMediaController=function(e){return{get:function(){return Promise.resolve(e)}}}}()},269:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,t.TaskMediaController=function(e){var n=t.getLog(),r=t.LogComponent.TASK,o=function(n,r){t.publishMetric({name:n,contactId:e.contactId,data:r||e})},i=function(e){e.onConnectionBroken((function(e){n.error(r,"Task Session connection broken").withException(e),o("Task Session connection broken",e)})),e.onConnectionEstablished((function(e){n.info(r,"Task Session connection established").withObject(e),o("Task Session connection established",e)}))};return{get:function(){return function(){o("Task media controller init",e.contactId),n.info(r,"Task media controller init").withObject(e);var a=t.TaskSession.create({contactId:e.contactId,initialContactId:e.initialContactId,websocketManager:t.core.getWebSocketManager()});return i(a),a.connect().then((function(){return n.info(r,"Task Session Successfully established for contactId %s",e.contactId),o("Task Session Successfully established",e.contactId),a})).catch((function(t){throw n.error(r,"Task Session establishement failed for contact %s",e.contactId).withException(t),o("Chat Session establishement failed",e.contactId,t),t}))}()}}}}()},414:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(t,n,r){return(n=function(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}(n))in t?Object.defineProperty(t,n,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[n]=r,t}!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t;var r,o="/request-storage-access",i={canRequest:!1,mode:"default",custom:{hideCCP:!0}},a={},s="",c=null,u=!1,l={INIT:"storageAccess::init",GRANTED:"storageAccess::granted",DENIED:"storageAccess::denied",REQUEST:"storageAccess::request"},p=function(){return{show:function(){c.style.display="block"},hide:function(){c.style.display="none"}}},d=function(){return a&&"custom"===a.mode},f=function(e){return e.match(/.connect.aws.a2z.com|.my.connect.aws|.govcloud.connect.aws|.awsapps.com/)},h=function(e){var t=new URL(e),n=t.origin,r=t.pathname;if(n.match(/.awsapps.com/)){var i="connect";return r.startsWith("/connect-gamma")&&(i="connect-gamma"),"".concat(n,"/").concat(i).concat(o)}return"".concat(n).concat(o)},g=function(e){return e.match(/^https?:\/\/localhost/)},m=function(){if(!s)throw new Error("[StorageAccess] [getlandAtPath] Invoke connect.storageAccess.init first");return f(s)||g(s)?new URL(s).pathname:"/connect/ccp-v2"},v=function(e){var n=e.onInit,r=e.onDeny,o=e.onGrant;function i(e){var a=e.data,s=e.source;if(t.core._getCCPIframe().contentWindow!==s)return!1;switch(t.core.initialized&&window.removeEventListener("message",i),a.event){case l.INIT:t.getLog().info("[StorageAccess][INIT] message recieved").withObject(a),n&&n(a);break;case l.GRANTED:t.getLog().info("[StorageAccess][GRANTED] message recieved").withObject(a),o&&o(a);break;case l.DENIED:t.getLog().info("[StorageAccess][DENIED] message recieved").withObject(a),r&&r(a);break;default:t.core.initialized&&window.removeEventListener("message",i)}}return a.canRequest&&window.addEventListener("message",i),{unsubscribe:function(){window.removeEventListener("message",i)}}};t.storageAccess=Object.freeze({canRequest:function(){return a.canRequest},optOutFromRequestAccess:function(){i.canRequest=!1},optInForRequestAccess:function(){i.canRequest=!0},init:function(e,r){var o=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};t.assertNotNull(e,"ccpUrl"),t.assertNotNull(r,"container"),c=r,s=e,function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};e.custom=e.custom||{},(a=n(n(n({},i),e),{},{custom:n(n({},i.custom),e.custom)})).canRequest=!("false"===a.canRequest||!1===a.canRequest)}(o),t.getLog().info("[StorageAccess][init] Request Storage Acccess init called with ccpUrl - ".concat(e," - ").concat(a.canRequest?"Proceeding with requesting storage access":"user has opted out, skipping request storage access")).withObject(a)},setupRequestHandlers:function(e){var n=e.onGrant;r&&r.unsubscribe(),r=v({onInit:function(e){console.log("%c[StorageAccess][INIT]","background:yellow; color:black; font-size:large"),t.getLog().info("[StorageAccess][onInit] callback executed").withObject(null==e?void 0:e.data),null!=e&&e.data.hasAccess||!d()||p().show()},onDeny:function(){console.log("%c[StorageAccess][DENIED]","background:red; color:black; font-size:large"),t.getLog().info("[StorageAccess][onDeny] callback executed"),d()&&p().show()},onGrant:function(){var e;console.log("%c[StorageAccess][GRANTED]","background:lime; color:black; font-size:large"),t.getLog().info("[StorageAccess][onGrant] callback executed"),d()&&(null===(e=a)||void 0===e||null===(e=e.custom)||void 0===e?void 0:e.hideCCP)&&p().hide(),u||(n(),u=!0)}})},getRequestStorageAccessUrl:function(){if(!s)throw new Error("[StorageAccess] [getRequestStorageAccessUrl] Invoke connect.storageAccess.init first");if(f(s))return h(s);if(g(s))return t.getLog().info("[StorageAccess] [CCP] Local testing"),"".concat(s).concat(o);if(a.instanceUrl&&f(a.instanceUrl))return t.getLog().info("[StorageAccess] [getRequestStorageAccessUrl] Customer has provided storageParams.instanceUrl ".concat(a.instanceUrl)),h(a.instanceUrl);if(a.instanceUrl&&g(a.instanceUrl))return t.getLog().info("[StorageAccess] [getRequestStorageAccessUrl] Local testing"),"".concat(a.instanceUrl).concat(o);throw t.getLog().error("[StorageAccess] [getRequestStorageAccessUrl] Invalid Connect instance/CCP URL provided, please pass the correct ccpUrl or storageAccess.instanceUrl parameters"),new Error("[StorageAccess] [getRequestStorageAccessUrl] Invalid Connect instance/CCP URL provided, please pass the valid Connect CCP URL or in case CCP URL is configured to be the SSO URL then use storageAccess.instanceUrl and pass the Connect CCP URL")},storageAccessEvents:l,resetStorageAccessState:function(){a={},s="",c=null,u=!1},getOnGrantCallbackInvoked:function(){return u},getStorageAccessParams:function(){return a},onRequest:v,request:function(){t.core._getCCPIframe().contentWindow.postMessage({event:l.REQUEST,data:n(n({},a),{},{landat:m()})},"*")}})}()},906:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(){"use strict";t=function(){return r};var n,r={},o=Object.prototype,i=o.hasOwnProperty,a=Object.defineProperty||function(e,t,n){e[t]=n.value},s="function"==typeof Symbol?Symbol:{},c=s.iterator||"@@iterator",u=s.asyncIterator||"@@asyncIterator",l=s.toStringTag||"@@toStringTag";function p(e,t,n){return Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}),e[t]}try{p({},"")}catch(n){p=function(e,t,n){return e[t]=n}}function d(e,t,n,r){var o=t&&t.prototype instanceof b?t:b,i=Object.create(o.prototype),s=new N(r||[]);return a(i,"_invoke",{value:R(e,n,s)}),i}function f(e,t,n){try{return{type:"normal",arg:e.call(t,n)}}catch(e){return{type:"throw",arg:e}}}r.wrap=d;var h="suspendedStart",g="suspendedYield",m="executing",v="completed",y={};function b(){}function E(){}function S(){}var C={};p(C,c,(function(){return this}));var T=Object.getPrototypeOf,I=T&&T(T(P([])));I&&I!==o&&i.call(I,c)&&(C=I);var w=S.prototype=b.prototype=Object.create(C);function A(e){["next","throw","return"].forEach((function(t){p(e,t,(function(e){return this._invoke(t,e)}))}))}function _(t,n){function r(o,a,s,c){var u=f(t[o],t,a);if("throw"!==u.type){var l=u.arg,p=l.value;return p&&"object"==e(p)&&i.call(p,"__await")?n.resolve(p.__await).then((function(e){r("next",e,s,c)}),(function(e){r("throw",e,s,c)})):n.resolve(p).then((function(e){l.value=e,s(l)}),(function(e){return r("throw",e,s,c)}))}c(u.arg)}var o;a(this,"_invoke",{value:function(e,t){function i(){return new n((function(n,o){r(e,t,n,o)}))}return o=o?o.then(i,i):i()}})}function R(e,t,r){var o=h;return function(i,a){if(o===m)throw Error("Generator is already running");if(o===v){if("throw"===i)throw a;return{value:n,done:!0}}for(r.method=i,r.arg=a;;){var s=r.delegate;if(s){var c=O(s,r);if(c){if(c===y)continue;return c}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(o===h)throw o=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);o=m;var u=f(e,t,r);if("normal"===u.type){if(o=r.done?v:g,u.arg===y)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(o=v,r.method="throw",r.arg=u.arg)}}}function O(e,t){var r=t.method,o=e.iterator[r];if(o===n)return t.delegate=null,"throw"===r&&e.iterator.return&&(t.method="return",t.arg=n,O(e,t),"throw"===t.method)||"return"!==r&&(t.method="throw",t.arg=new TypeError("The iterator does not provide a '"+r+"' method")),y;var i=f(o,e.iterator,t.arg);if("throw"===i.type)return t.method="throw",t.arg=i.arg,t.delegate=null,y;var a=i.arg;return a?a.done?(t[e.resultName]=a.value,t.next=e.nextLoc,"return"!==t.method&&(t.method="next",t.arg=n),t.delegate=null,y):a:(t.method="throw",t.arg=new TypeError("iterator result is not an object"),t.delegate=null,y)}function L(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function k(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function N(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(L,this),this.reset(!0)}function P(t){if(t||""===t){var r=t[c];if(r)return r.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var o=-1,a=function e(){for(;++o<t.length;)if(i.call(t,o))return e.value=t[o],e.done=!1,e;return e.value=n,e.done=!0,e};return a.next=a}}throw new TypeError(e(t)+" is not iterable")}return E.prototype=S,a(w,"constructor",{value:S,configurable:!0}),a(S,"constructor",{value:E,configurable:!0}),E.displayName=p(S,l,"GeneratorFunction"),r.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===E||"GeneratorFunction"===(t.displayName||t.name))},r.mark=function(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,S):(e.__proto__=S,p(e,l,"GeneratorFunction")),e.prototype=Object.create(w),e},r.awrap=function(e){return{__await:e}},A(_.prototype),p(_.prototype,u,(function(){return this})),r.AsyncIterator=_,r.async=function(e,t,n,o,i){void 0===i&&(i=Promise);var a=new _(d(e,t,n,o),i);return r.isGeneratorFunction(t)?a:a.next().then((function(e){return e.done?e.value:a.next()}))},A(w),p(w,l,"Generator"),p(w,c,(function(){return this})),p(w,"toString",(function(){return"[object Generator]"})),r.keys=function(e){var t=Object(e),n=[];for(var r in t)n.push(r);return n.reverse(),function e(){for(;n.length;){var r=n.pop();if(r in t)return e.value=r,e.done=!1,e}return e.done=!0,e}},r.values=P,N.prototype={constructor:N,reset:function(e){if(this.prev=0,this.next=0,this.sent=this._sent=n,this.done=!1,this.delegate=null,this.method="next",this.arg=n,this.tryEntries.forEach(k),!e)for(var t in this)"t"===t.charAt(0)&&i.call(this,t)&&!isNaN(+t.slice(1))&&(this[t]=n)},stop:function(){this.done=!0;var e=this.tryEntries[0].completion;if("throw"===e.type)throw e.arg;return this.rval},dispatchException:function(e){if(this.done)throw e;var t=this;function r(r,o){return s.type="throw",s.arg=e,t.next=r,o&&(t.method="next",t.arg=n),!!o}for(var o=this.tryEntries.length-1;o>=0;--o){var a=this.tryEntries[o],s=a.completion;if("root"===a.tryLoc)return r("end");if(a.tryLoc<=this.prev){var c=i.call(a,"catchLoc"),u=i.call(a,"finallyLoc");if(c&&u){if(this.prev<a.catchLoc)return r(a.catchLoc,!0);if(this.prev<a.finallyLoc)return r(a.finallyLoc)}else if(c){if(this.prev<a.catchLoc)return r(a.catchLoc,!0)}else{if(!u)throw Error("try statement without catch or finally");if(this.prev<a.finallyLoc)return r(a.finallyLoc)}}}},abrupt:function(e,t){for(var n=this.tryEntries.length-1;n>=0;--n){var r=this.tryEntries[n];if(r.tryLoc<=this.prev&&i.call(r,"finallyLoc")&&this.prev<r.finallyLoc){var o=r;break}}o&&("break"===e||"continue"===e)&&o.tryLoc<=t&&t<=o.finallyLoc&&(o=null);var a=o?o.completion:{};return a.type=e,a.arg=t,o?(this.method="next",this.next=o.finallyLoc,y):this.complete(a)},complete:function(e,t){if("throw"===e.type)throw e.arg;return"break"===e.type||"continue"===e.type?this.next=e.arg:"return"===e.type?(this.rval=this.arg=e.arg,this.method="return",this.next="end"):"normal"===e.type&&t&&(this.next=t),y},finish:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.finallyLoc===e)return this.complete(n.completion,n.afterLoc),k(n),y}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.tryLoc===e){var r=n.completion;if("throw"===r.type){var o=r.arg;k(n)}return o}}throw Error("illegal catch attempt")},delegateYield:function(e,t,r){return this.delegate={iterator:P(e),resultName:t,nextLoc:r},"next"===this.method&&(this.arg=n),y}},r}function n(e,t,n,r,o,i,a){try{var s=e[i](a),c=s.value}catch(e){return void n(e)}s.done?t(c):Promise.resolve(c).then(r,o)}function r(e){return function(){var t=this,r=arguments;return new Promise((function(o,i){var a=e.apply(t,r);function s(e){n(a,o,i,s,c,"next",e)}function c(e){n(a,o,i,s,c,"throw",e)}s(void 0)}))}}!function(){var e=this||globalThis,n=e.connect||{};e.connect=n,e.lily=n;var o=function(e){n.assertNotNull(e,"ringtoneConfig"),this._audio=null,this._deviceId="",this._ringtoneUrl=e.ringtoneUrl,this._loadRingtone(this._ringtoneUrl).catch((function(){})),this._driveRingtone()};o.prototype._loadRingtone=function(e){var t=this;return new Promise((function(r,o){e||o(Error("ringtoneUrl is required!")),t._audio=new Audio(e),t._audio.loop=!0,t.setOutputDevice(t._deviceId);var i=setTimeout((function(){n.getLog().warn("Ringtone isn't loaded in 1 second but proceeding: ",+e).sendInternalLogToServer(),r()}),1e3);t._audio.addEventListener("canplay",(function(){n.getLog().info("Ringtone is ready to play: ",+e).sendInternalLogToServer(),clearTimeout(i),r()})),t._audio.addEventListener("error",(function(){n.getLog().error("Ringtone load error: ",+e).sendInternalLogToServer(),clearTimeout(i),o(Error("Ringtone load error: "+e))}))}))},o.prototype._driveRingtone=function(){throw new Error("Not implemented.")},o.prototype._startRingtone=function(){var e=r(t().mark((function e(o){var i,a,s=this,c=arguments;return t().wrap((function(e){for(;;)switch(e.prev=e.next){case 0:return i=c.length>1&&void 0!==c[1]?c[1]:0,a=c.length>2&&void 0!==c[2]?c[2]:[],e.abrupt("return",new Promise((function(e,c){s._audio||c(Error("No audio object found")),n.getLog().info("Attempting to start ringtone to device ".concat(s._audio.sinkId||"''")).sendInternalLogToServer(),s._audio.play().then((function(){s._publishTelemetryEvent("Ringtone Start",o),n.getLog().info("Ringtone Start: Succeeded with ".concat(i," retries remaining")).withObject({errorList:a,contactId:o.getContactId()}).sendInternalLogToServer(),e()})).catch(function(){var u=r(t().mark((function r(u){return t().wrap((function(t){for(;;)switch(t.prev=t.next){case 0:if(s._publishTelemetryEvent("Ringtone Playback Failure",o),n.getLog().error("Ringtone Playback Failure: ".concat(i," retries remaining.")).withException(u).withObject({currentSrc:s._audio.currentSrc,sinkId:s._audio.sinkId,volume:s._audio.volume,contactId:o.getContactId()}).sendInternalLogToServer(),a.push(u.toString()),!(i>0)){t.next=10;break}return t.next=6,s._loadRingtone(s._ringtoneUrl).catch((function(){}));case 6:return t.next=8,s._startRingtone(o,i-1,a).then(e).catch((function(){return c(a)}));case 8:t.next=12;break;case 10:n.getLog().error("Ringtone Retries Exhausted").withObject({errorList:a,contactId:o.getContactId()}).sendInternalLogToServer(),c(a);case 12:case"end":return t.stop()}}),r)})));return function(e){return u.apply(this,arguments)}}())})));case 3:case"end":return e.stop()}}),e)})));return function(t){return e.apply(this,arguments)}}(),o.prototype._stopRingtone=function(e){this._audio&&(this._audio.pause(),this._audio.currentTime=0,this._publishTelemetryEvent("Ringtone Stop",e),n.getLog().info("Ringtone Stop").sendInternalLogToServer())},o.prototype.stopRingtone=function(){this._stopRingtone()},o.prototype._ringtoneSetup=function(e){var t=this;n.ifMaster(n.MasterTopics.RINGTONE,(function(){t._startRingtone(e,2).catch((function(){})),e.onConnected(lily.hitch(t,t._stopRingtone)),e.onAccepted(lily.hitch(t,t._stopRingtone)),e.onEnded(lily.hitch(t,t._stopRingtone)),e.onRefresh((function(e){e.getStatus().type!==n.ContactStatusType.CONNECTING&&e.getStatus().type!==n.ContactStatusType.INCOMING&&t._stopRingtone()}))}))},o.prototype._publishTelemetryEvent=function(e,t){t&&t.getContactId()&&n.publishMetric({name:e,contactId:t.getContactId()})},o.prototype.setOutputDevice=function(e){var t=this;return new Promise((function(n,r){t._audio&&t._audio.setSinkId?t._audio.setSinkId(e).then((function(){t._deviceId=e,n(e)})).catch((function(e){r("RingtoneEngineBase.setOutputDevice failed: audio.setSinkId() failed with error ".concat(e))})):r("RingtoneEngineBase.setOutputDevice failed: ".concat(t._audio?"audio":"audio.setSinkId"," not found."))}))};var i=function(e){o.call(this,e)};(i.prototype=Object.create(o.prototype)).constructor=i,i.prototype._driveRingtone=function(){var e=this,t=function(t){t.getType()===n.ContactType.VOICE&&t.isSoftphoneCall()&&t.isInbound()&&(e._ringtoneSetup(t),e._publishTelemetryEvent("Ringtone Connecting",t),n.getLog().info("Ringtone Connecting").sendInternalLogToServer())};n.contact((function(e){e.onConnecting(t)})),(new n.Agent).getContacts().forEach((function(e){e.getStatus().type===n.ContactStatusType.CONNECTING&&t(e)}))};var a=function(e){o.call(this,e)};(a.prototype=Object.create(o.prototype)).constructor=a,a.prototype._driveRingtone=function(){var e=this,t=function(t){t.getType()===lily.ContactType.CHAT&&t.isInbound()&&0===t.getConnections().filter((function(e){return e.getType()===n.ConnectionType.AGENT&&e.isSilentMonitor()})).length&&(e._ringtoneSetup(t),e._publishTelemetryEvent("Chat Ringtone Connecting",t),n.getLog().info("Chat Ringtone Connecting").sendInternalLogToServer())};n.contact((function(e){e.onConnecting(t)}))};var s=function(e){o.call(this,e)};(s.prototype=Object.create(o.prototype)).constructor=s,s.prototype._driveRingtone=function(){var e=this,t=function(t){t.getType()===lily.ContactType.TASK&&t.isInbound()&&(e._ringtoneSetup(t),e._publishTelemetryEvent("Task Ringtone Connecting",t),n.getLog().info("Task Ringtone Connecting").sendInternalLogToServer())};n.contact((function(e){e.onConnecting(t)}))};var c=function(e){o.call(this,e)};(c.prototype=Object.create(o.prototype)).constructor=c,c.prototype._driveRingtone=function(){var e=this,t=function(t){t.getType()===n.ContactType.EMAIL&&t.isInbound()&&(e._ringtoneSetup(t),e._publishTelemetryEvent("Email Ringtone Connecting",t),n.getLog().info("Email Ringtone Connecting").sendInternalLogToServer())};n.contact((function(e){e.onConnecting(t)}))};var u=function(e){o.call(this,e)};(u.prototype=Object.create(o.prototype)).constructor=u,u.prototype._driveRingtone=function(){var e=this;n.contact((function(t){t.onIncoming((function(){t.getType()===lily.ContactType.QUEUE_CALLBACK&&(e._ringtoneSetup(t),e._publishTelemetryEvent("Callback Ringtone Connecting",t),n.getLog().info("Callback Ringtone Connecting").sendInternalLogToServer())}))}))},n.VoiceRingtoneEngine=i,n.ChatRingtoneEngine=a,n.TaskRingtoneEngine=s,n.QueueCallbackRingtoneEngine=u,n.EmailRingtoneEngine=c}()},806:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(t,n,r){return(n=function(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}(n))in t?Object.defineProperty(t,n,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[n]=r,t}!function(){var t=this||globalThis,r=t.connect||{};t.connect=r,t.lily=r,t.ccpVersion="V2";var o="CITRIX",i="AWS_WORKSPACE",a={};a[r.SoftphoneCallType.AUDIO_ONLY]="Audio",a[r.SoftphoneCallType.VIDEO_ONLY]="Video",a[r.SoftphoneCallType.AUDIO_VIDEO]="AudioVideo",a[r.SoftphoneCallType.NONE]="None";var s="audio_input",c="audio_output";({})[r.ContactType.VOICE]="Voice";var u=[],l=[],p=[],d={},f={},h=0,g=0,m=0,v=0,y=0,b=!1,E=!1,S=null,C=null,T=null,I=null,w=r.SoftphoneErrorTypes,A={},_=r.randomId(),R=function(e){return new Promise((function(t,n){r.core.getClient().call(r.ClientMethods.CREATE_TRANSPORT,e,{success:function(e){t(e.softphoneTransport.softphoneMediaConnections)},failure:function(e){e.message&&e.message.includes("SoftphoneConnectionLimitBreachedException")&&G("multiple_softphone_active_sessions","Number of active sessions are more then allowed limit.",""),n(Error("requestIceAccess failed"))},authFailure:function(){n(Error("Authentication failed while requestIceAccess"))},accessDenied:function(){n(Error("Access Denied while requestIceAccess"))}})}))},O=function(){var e=this,n=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},a=this;this.rtcPeerConnectionFactory=null,this.rtcJsStrategy=null,this.rtcPeerConnectionManager=null,this._setRtcJsStrategy=function(){if(n.VDIPlatform){S=n.VDIPlatform;try{if(n.VDIPlatform===o)this.rtcJsStrategy=new r.CitrixVDIStrategy,I.info("[SoftphoneManager] Strategy constructor retrieved: ".concat(this.rtcJsStrategy)).sendInternalLogToServer();else{if(n.VDIPlatform!==i)throw new Error("VDI Strategy not supported");this.rtcJsStrategy=new r.DCVWebRTCStrategy,I.info("[SoftphoneManager] Strategy constructor retrieved: ".concat(this.rtcJsStrategy)).sendInternalLogToServer()}}catch(e){throw"VDI Strategy not supported"===e.message?(G(w.VDI_STRATEGY_NOT_SUPPORTED,e.message,""),e):"Citrix WebRTC redirection feature is NOT supported!"===e.message||"DCV WebRTC redirection feature is NOT supported!"===e.message?(G(w.VDI_REDIR_NOT_SUPPORTED,e.message,""),e):(G(w.OTHER,e.message,""),e)}}},this._refreshRtcPeerConnectionFactory=function(){var e;null!=r&&null!==(e=r.core)&&void 0!==e&&null!==(e=e.softphoneManager)&&void 0!==e&&null!==(e=e.rtcPeerConnectionFactory)&&void 0!==e&&e.close&&r.core.softphoneManager.rtcPeerConnectionFactory.close(),r.RtcPeerConnectionFactory&&(this.rtcJsStrategy?this.rtcPeerConnectionFactory=new r.RtcPeerConnectionFactory(I,r.core.getWebSocketManager(),_,r.hitch(a,R,{transportType:"softphone",softphoneClientId:_}),r.hitch(a,G),this.rtcJsStrategy):this.rtcPeerConnectionFactory=new r.RtcPeerConnectionFactory(I,r.core.getWebSocketManager(),_,r.hitch(a,R,{transportType:"softphone",softphoneClientId:_}),r.hitch(a,G)))},this._initiateRtcPeerConnectionManager=function(){var e;null!=r&&null!==(e=r.core)&&void 0!==e&&null!==(e=e.softphoneManager)&&void 0!==e&&null!==(e=e.rtcPeerConnectionManager)&&void 0!==e&&e.close&&(r.core.softphoneManager.rtcPeerConnectionManager.close(),r.core.softphoneManager.rtcPeerConnectionManager=null);var o,i,s=n.isSoftphonePersistentConnectionEnabled;t.localStorage.getItem(BROWSER_ID)||t.localStorage.setItem(BROWSER_ID,AWS.util.uuid.v4()),o=t.localStorage.getItem(BROWSER_ID),r.RtcPeerConnectionManager?(b=!1,null!==(i=a.rtcPeerConnectionFactory)&&void 0!==i&&i.close&&(a.rtcPeerConnectionFactory.close(),a.rtcPeerConnectionFactory=null),a.rtcPeerConnectionManager=new r.RtcPeerConnectionManager(null,null,r.hitch(a,R,{transportType:"softphone",softphoneClientId:_}),r.hitch(a,G),_,null,I,null,null,r.core.getWebSocketManager(),null===a.rtcJsStrategy?new r.StandardStrategy:a.rtcJsStrategy,s,o)):I.info("RtcPeerConnectionManager does NOT exist, please upgrade RTC.js")},(I=new oe(r.getLog())).info("[Softphone Manager] softphone manager initialization has begun").sendInternalLogToServer(),!1!==n.allowEarlyGum&&(r.isChromeBrowser()||r.isEdgeBrowser())?(I.info("[Softphone Manager] earlyGum mechanism enabled").sendInternalLogToServer(),b=!0):(I.info("[Softphone Manager] earlyGum mechanism NOT enabled").sendInternalLogToServer(),b=!1),I.info("[SoftphoneManager] Client Provided Strategy: ".concat(n.VDIPlatform)).sendInternalLogToServer(),this._setRtcJsStrategy(),this._refreshRtcPeerConnectionFactory(),r.core._allowSoftphonePersistentConnection&&null===this.rtcPeerConnectionManager&&this._initiateRtcPeerConnectionManager(),r.agent((function(t){var n=t.onRefresh((function(t){if(e.rtcPeerConnectionManager){var o=t.getConfiguration().softphonePersistentConnection;e.rtcPeerConnectionManager.isPPCEnabled!==o&&(e.rtcPeerConnectionManager.isPPCEnabled=o,e.rtcPeerConnectionManager.isPPCEnabled?(I.info("softphonePersistentConnection changed to ture, initiate a persistent peer connection").sendInternalLogToServer(),e.rtcPeerConnectionManager.rtcJsStrategy=e.rtcJsStrategy,e.rtcPeerConnectionManager.closeEarlyMediaConnection(),e.rtcPeerConnectionManager.requestPeerConnection().then((function(){e.rtcPeerConnectionManager.createSession(),e.rtcPeerConnectionManager.connect()}))):(I.info("softphonePersistentConnection changed to false, destroy the existing persistent peer connection").sendInternalLogToServer(),e.rtcPeerConnectionManager.destroy(),e.rtcPeerConnectionManager.requestPeerConnection()))}else r.core._allowSoftphonePersistentConnection?e._initiateRtcPeerConnectionManager():n.unsubscribe()}))})),O.isBrowserSoftPhoneSupported()||G(w.UNSUPPORTED_BROWSER,"Connect does not support this browser. Some functionality may not work. ",""),n.VDIPlatform!==i&&B({success:function(e){W("ConnectivityCheckResult",null,{connectivityCheckType:"MicrophonePermission",status:"granted"}),W("MicCheckSucceeded",null,{context:"Initializing Softphone Manager"},!0)},failure:function(e){G(e,"Your microphone is not enabled in your browser. ",""),W("ConnectivityCheckResult",null,{connectivityCheckType:"MicrophonePermission",status:"denied"}),W("GumFailed",null,{context:"Initializing Softphone Manager"},!0)}});var s=k(),c=N(),u=P(!n.disableEchoCancellation);D(),this.ringtoneEngine=null;var l={},p={},d=!1,f=null,h=null,g=function(){d=!1,f=null,h=null};this.getSession=function(e){return l[e]},this.replaceLocalMediaTrack=function(e,t){var r=A[e].stream;if(r){var o=r.getAudioTracks()[0];t.enabled=o.enabled,o.enabled=!1,r.removeTrack(o),n.VDIPlatform===i&&o.stop(),r.addTrack(t)}};var m=function(t){if(l.hasOwnProperty(t)){var n=l[t];new Promise((function(r,o){delete l[t],delete p[t],e.rtcPeerConnectionManager?e.rtcPeerConnectionManager.hangup():n.hangup()})).catch((function(e){lily.getLog().warn("There was an error destroying the softphone session for connection ID ".concat(t," : ").concat(e.message)).withObject({agentConnectionId:t,errorMessage:e.message}).sendInternalLogToServer()}))}};this._clearAllSessions=function(){for(var e in r.getLog().info("Clearing all active sessions").sendInternalLogToServer(),l)l.hasOwnProperty(e)&&m(e)},this.startSession=function(e,t){var o=d?f:e,i=d?h:t;if(o&&i){g(),p[i]=!0,I.info("Softphone call detected:","contactId "+o.getContactId(),"agent connectionId "+i).sendInternalLogToServer(),function(e){if(Object.keys(e).length>0){for(var t in e)e.hasOwnProperty(t)&&(H("MultiSessionHangUp",e[t].callId,t),m(t));throw new Error("duplicate session detected, refusing to setup new connection")}}(l),o.getStatus().type===r.ContactStatusType.CONNECTING&&W("Softphone Connecting",o.getContactId()),X();var a,s,c=o.getAgentConnection().getSoftphoneMediaInfo(),u=q(c.callConfigJson);u.useWebSocketProvider&&(a=r.core.getWebSocketManager()),(s=this.rtcJsStrategy?new r.RTCSession(u.signalingEndpoint,u.iceServers,c.callContextToken,I,o.getContactId(),i,a,this.rtcJsStrategy):new r.RTCSession(u.signalingEndpoint,u.iceServers,c.callContextToken,I,o.getContactId(),i,a)).echoCancellation=!n.disableEchoCancellation,l[i]=s,r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.ConnectionEvents.SESSION_INIT,data:{connectionId:i}}),s.onSessionFailed=function(e,t){delete l[i],delete p[i],j(e,t),V(o.getContactId(),t),te(o,e.sessionReport)},s.onSessionConnected=function(e){W("Softphone Session Connected",o.getContactId()),r.becomeMaster(r.MasterTopics.SEND_LOGS),K(e),Y(o),L(o)},s.onSessionCompleted=function(e){W("Softphone Session Completed",o.getContactId()),delete l[i],delete p[i],te(o,e.sessionReport),x(i)},s.onLocalStreamAdded=function(e,t){A[i]={stream:t},r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.AgentEvents.LOCAL_MEDIA_STREAM_CREATED,data:{connectionId:i}})},s.remoteAudioElement=document.getElementById("remote-audio")||window.parent.parent.document.getElementById("remote-audio"),this.rtcPeerConnectionFactory?s.connect(this.rtcPeerConnectionFactory.get(u.iceServers)):s.connect()}};var v=function(e,t){var n;l[t]&&function(e){return e.getStatus().type===r.ContactStatusType.ENDED||e.getStatus().type===r.ContactStatusType.ERROR||e.getStatus().type===r.ContactStatusType.MISSED}(e)&&(m(t),g()),!e.isSoftphoneCall()||p[t]||e.getStatus().type!==r.ContactStatusType.CONNECTING&&e.getStatus().type!==r.ContactStatusType.INCOMING||(W("SoftphoneConfigDetected",e.getContactId(),{},!0),r.isFirefoxBrowser()&&r.hasOtherConnectedCCPs()?(I.info("[Softphone Manager] Postpone starting session: "+e.getContactId()).sendInternalLogToServer(),function(e,t){d=!0,f=e,h=t}(e,t)):b&&null!==(n=r.core.userMediaProvider)&&void 0!==n&&n.precapturedMediaStreamAvailable()?(E=!0,I.info("[Softphone Manager] starting session using precapturedMediaStream").sendInternalLogToServer(),a.startSession(e,t,r.core.userMediaProvider.getPrecapturedMediaStream())):(E=!1,r.core._isEarlyGumDisabled&&(b=!1),a.startSession(e,t)))},y=function(e){var t=e.getAgentConnection().connectionId;I.info("Contact detected:","contactId "+e.getContactId(),"agent connectionId "+t).sendInternalLogToServer(),p[t]||(e.onRefresh((function(e){v(e,t)})),e.onError((function(e){r.ifMaster(r.MasterTopics.SOFTPHONE,(function(){publishBatchedSoftphoneErrors(e.contactId)}),(function(){}),!0)})),e.onConnected((function(e){r.ifMaster(r.MasterTopics.SOFTPHONE,(function(){isConnected=!0,deleteContactFromErrorMap(e.contactId)}),(function(){}),!0)})),e.onDestroy((function(){!function(e){l[e]&&m(e)}(t),A[t]&&x(t)})))},C=r.contact(y);(new r.Agent).getContacts().forEach((function(e){var t=e.getAgentConnection().connectionId;I.info("Contact exist in the snapshot. Reinitiate the Contact and RTC session creation for contactId"+e.getContactId(),"agent connectionId "+t).sendInternalLogToServer(),y(e),v(e,t)})),this.terminate=function(){C&&C.unsubscribe&&C.unsubscribe(),s&&s.unsubscribe&&s.unsubscribe(),c&&c.unsubscribe&&c.unsubscribe(),u&&u.unsubscribe&&u.unsubscribe(),e.rtcPeerConnectionFactory.clearIdleRtcPeerConnectionTimerId&&e.rtcPeerConnectionFactory.clearIdleRtcPeerConnectionTimerId(),e.rtcPeerConnectionFactory=null,e.rtcPeerConnectionManager&&e.rtcPeerConnectionManager.clearIdleRtcPeerConnectionTimerId&&e.rtcPeerConnectionManager.clearIdleRtcPeerConnectionTimerId()}},L=function(e){var t=r.core.getUpstream(),n=e.getAgentConnection();if(n){var o=n.getSoftphoneMediaInfo();o?!0===o.autoAccept?(I.info("Auto-accept is enabled, sending out Accepted event to stop ringtone..").sendInternalLogToServer(),t.sendUpstream(r.EventType.BROADCAST,{event:r.ContactEvents.ACCEPTED,data:new r.Contact(e.contactId)}),t.sendUpstream(r.EventType.BROADCAST,{event:r.core.getContactEventName(r.ContactEvents.ACCEPTED,e.contactId),data:new r.Contact(e.contactId)})):I.info("Auto-accept is disabled, ringtone will be stopped by user action.").sendInternalLogToServer():I.info("Not able to retrieve the auto-accept setting from null SoftphoneMediaInfo, ignoring event publish..").sendInternalLogToServer()}else I.info("Not able to retrieve the auto-accept setting from null AgentConnection, ignoring event publish..").sendInternalLogToServer()},k=function(){return r.core.getEventBus().subscribe(r.EventType.MUTE,M)},N=function(){return r.core.getEventBus().subscribe(r.ConfigurationEvents.SET_SPEAKER_DEVICE,U)},P=function(e){return r.core.getEventBus().subscribe(r.ConfigurationEvents.SET_MICROPHONE_DEVICE,(function(t){return F(n(n({},t),{},{enableEchoCancellation:e}))}))},D=function(){try{r.isChromeBrowser()&&r.getChromeBrowserVersion()>43&&navigator.permissions.query({name:"microphone"}).then((function(e){e.onchange=function(){I.info("Microphone Permission: "+e.state),W("ConnectivityCheckResult",null,{connectivityCheckType:"MicrophonePermission",status:e.state}),"denied"===e.state&&G(w.MICROPHONE_NOT_SHARED,"Your microphone is not enabled in your browser. ","")}}))}catch(e){I.error("Failed in detecting microphone permission status: "+e)}},x=function(e){delete A[e],r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.AgentEvents.MUTE_TOGGLE,data:{muted:!1}})},M=function(e){var t;if(0!==r.keys(A).length){for(var n in e&&void 0!==e.mute&&(t=e.mute),A)if(A.hasOwnProperty(n)){var o=A[n].stream;if(o){var i=o.getAudioTracks()[0];void 0!==t?(i.enabled=!t,A[n].muted=t,t?I.info("Agent has muted the contact, connectionId -  "+n).sendInternalLogToServer():I.info("Agent has unmuted the contact, connectionId - "+n).sendInternalLogToServer()):t=A[n].muted||!1}}r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.AgentEvents.MUTE_TOGGLE,data:{muted:t}})}},U=function(){var e=(arguments.length>0&&void 0!==arguments[0]?arguments[0]:{}).deviceId||"";if(r.getLog().info("[Audio Device Settings] Attempting to set speaker device ".concat(e)).sendInternalLogToServer(),e){var t=document.getElementById("remote-audio")||window.parent.parent.document.getElementById("remote-audio");t&&"function"==typeof t.setSinkId?t.setSinkId(e).then((function(){r.getLog().info("[Audio Device Settings] Speaker device ".concat(e," successfully set to speaker audio element")).sendInternalLogToServer(),r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.ConfigurationEvents.SPEAKER_DEVICE_CHANGED,data:{deviceId:e}})})).catch((function(t){r.getLog().error("[Audio Device Settings] Failed to set speaker device "+e).withException(t).sendInternalLogToServer()})):r.getLog().warn("[Audio Device Settings] Setting speaker device cancelled due to missing remoteAudioElement").sendInternalLogToServer()}else r.getLog().warn("[Audio Device Settings] Setting speaker device cancelled due to missing deviceId").sendInternalLogToServer()},F=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{},t=e.deviceId||"";if(r.getLog().info("[Audio Device Settings] Attempting to set microphone device ".concat(t)).sendInternalLogToServer(),0!==r.keys(A).length)if(t){var n=r.core.getSoftphoneManager(),o={audio:{deviceId:{exact:t}}};e.enableEchoCancellation||(o.audio.echoCancellation=!1),r.publishMetric({name:"echoCancellationCheck",data:{count:1,disableEchoCancellation:!e.enableEchoCancellation}}),navigator.mediaDevices.getUserMedia(o).then((function(e){try{var o=e.getAudioTracks()[0];for(var i in A)A.hasOwnProperty(i)&&(A[i].stream,n.getSession(i)._pc.getSenders()[0].replaceTrack(o).then((function(){n.replaceLocalMediaTrack(i,o),r.getLog().info("[Audio Device Settings] Microphone device ".concat(t," successfully set to local media stream in RTCRtpSender")).sendInternalLogToServer()})))}catch(e){return void r.getLog().error("[Audio Device Settings] Failed to set microphone device "+t).withException(e).sendInternalLogToServer()}r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.ConfigurationEvents.MICROPHONE_DEVICE_CHANGED,data:{deviceId:t}})})).catch((function(e){r.getLog().error("[Audio Device Settings] Failed to set microphone device "+t).withException(e).sendInternalLogToServer()}))}else r.getLog().warn("[Audio Device Settings] Setting microphone device cancelled due to missing deviceId").sendInternalLogToServer();else r.getLog().warn("[Audio Device Settings] Setting microphone device cancelled due to missing localMediaStream").sendInternalLogToServer()},j=function(e,t){if(t===r.RTCErrors.ICE_COLLECTION_TIMEOUT){for(var n="\n",o=0;o<e._iceServers.length;o++)for(var i=0;i<e._iceServers[o].urls.length;i++)n=n+e._iceServers[o].urls[i]+"\n";G(w.ICE_COLLECTION_TIMEOUT,"Ice collection timedout. ",n)}else t===r.RTCErrors.USER_BUSY?G(w.USER_BUSY_ERROR,"Softphone call UserBusy error. ",""):t===r.RTCErrors.SIGNALLING_HANDSHAKE_FAILURE?G(w.SIGNALLING_HANDSHAKE_FAILURE,"Handshaking with Signalling Server "+e._signalingUri+" failed. ",e._signalingUri):t===r.RTCErrors.GUM_TIMEOUT_FAILURE||t===r.RTCErrors.GUM_OTHER_FAILURE?G(w.MICROPHONE_NOT_SHARED,"Your microphone is not enabled in your browser. ",""):t===r.RTCErrors.SIGNALLING_CONNECTION_FAILURE?G(w.SIGNALLING_CONNECTION_FAILURE,"URL "+e._signalingUri+" cannot be reached. ",e._signalingUri):t===r.RTCErrors.CALL_NOT_FOUND?I.error("Softphone call failed due to CallNotFoundException.").sendInternalLogToServer():G(w.WEBRTC_ERROR,"webrtc system error. ","")},q=function(e){var t=e.replace(/&quot;/g,'"');return JSON.parse(t)},B=function(t){var n=t||{};n.success=n.success||function(){},n.failure=n.failure||function(){};var r={audio:!0},o=null;if("function"==typeof Promise){if("object"===e(navigator.mediaDevices)&&"function"==typeof navigator.mediaDevices.getUserMedia)o=navigator.mediaDevices.getUserMedia(r);else{if("function"!=typeof navigator.webkitGetUserMedia)return void n.failure(w.UNSUPPORTED_BROWSER);o=new Promise((function(e,t){navigator.webkitGetUserMedia(r,e,t)}))}return o.then((function(e){var t=e.getAudioTracks();t&&t.length>0?n.success(e):n.failure(w.MICROPHONE_NOT_SHARED)}),(function(e){n.failure(w.MICROPHONE_NOT_SHARED)})),o}n.failure(w.UNSUPPORTED_BROWSER)},G=function(e,t,n){I.error("Softphone error occurred : ",e,t||"").sendInternalLogToServer(),r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.AgentEvents.SOFTPHONE_ERROR,data:new r.SoftphoneError(e,t,n)})},V=function(e,t){W("Softphone Session Failed",e,{failedReason:t})},W=function(e,t,n){r.publishMetric({name:e,contactId:t,data:n})},H=function(e,t,n){W(e,t,[{name:"AgentConnectionId",value:n}]),I.info("Publish multiple session error metrics",e,"contactId "+t,"agent connectionId "+n).sendInternalLogToServer()};O.isBrowserSoftPhoneSupported=function(){return!!(r.isOperaBrowser()&&r.getOperaBrowserVersion()>17)||!!(r.isChromeBrowser()&&r.getChromeBrowserVersion()>22)||!!(r.isFirefoxBrowser()&&r.getFirefoxBrowserVersion()>21)};var z=function(e){var t=u.slice();u=[],t.length>0&&e.sendSoftphoneMetrics(t,{success:function(){I.info("sendSoftphoneMetrics success"+JSON.stringify(t)).sendInternalLogToServer()},failure:function(e){I.error("sendSoftphoneMetrics failed.").withObject(e).sendInternalLogToServer()}})},K=function(e){C=window.setInterval((function(){e.getUserAudioStats().then((function(e){var t=d,n=J(d=e,t,s);u.push(n),Q(n)}),(function(e){I.debug("Failed to get user audio stats.",e).sendInternalLogToServer()})),e.getRemoteAudioStats().then((function(e){var t=f,n=J(f=e,t,c);u.push(n),Q(n)}),(function(e){I.debug("Failed to get remote audio stats.",e).sendInternalLogToServer()}))}),1e3)},Y=function(e){T=window.setInterval((function(){z(e)}),3e4)},X=function(){d=null,f=null,u=[],l=[],p=[],C=null,T=null,h=0,g=0,m=0,v=0,y=0},J=function(e,t,n){if(t&&e){var r=e.packetsLost>t.packetsLost?e.packetsLost-t.packetsLost:0,o=e.packetsCount>t.packetsCount?e.packetsCount-t.packetsCount:0;return Z(o,n),$(e.audioLevel,n),new ne(e.timestamp,r,o,n,e.audioLevel,e.jbMilliseconds,e.rttMilliseconds)}return new ne(e.timestamp,e.packetsLost,e.packetsCount,n,e.audioLevel,e.jbMilliseconds,e.rttMilliseconds)},Q=function(e){if(e.softphoneStreamType===s){for(;l.length>=10800;)l.shift();l.push(e)}else if(e.softphoneStreamType===c){for(;p.length>=10800;)p.shift();p.push(e)}},Z=function(e,t){t===s?(y++,e<=0?h++:h=0):t===c&&(e<=0?m++:m=0)},$=function(e,t){t===s?null!==e&&e<=1?g++:g=0:t===c&&(null!==e&&e<=1?v++:v=0)},ee=function(e){return null!==e&&window.clearInterval(e),null},te=function(e,o){C=ee(C),T=ee(T),function(e,o,i,a){o.streamStats=[re(i,s),re(a,c)];var u={callStartTime:o.sessionStartTime,callEndTime:o.sessionEndTime,gumTimeMillis:o.gumTimeMillis,initializationTimeMillis:o.initializationTimeMillis,iceCollectionTimeMillis:o.iceCollectionTimeMillis,signallingConnectTimeMillis:o.signallingConnectTimeMillis,handshakingTimeMillis:o.handshakingTimeMillis,preTalkingTimeMillis:o.preTalkingTimeMillis,talkingTimeMillis:o.talkingTimeMillis,cleanupTimeMillis:o.cleanupTimeMillis,iceCollectionFailure:o.iceCollectionFailure,signallingConnectionFailure:o.signallingConnectionFailure,handshakingFailure:o.handshakingFailure,gumOtherFailure:o.gumOtherFailure,gumTimeoutFailure:o.gumTimeoutFailure,createOfferFailure:o.createOfferFailure,setLocalDescriptionFailure:o.setLocalDescriptionFailure,userBusyFailure:o.userBusyFailure,invalidRemoteSDPFailure:o.invalidRemoteSDPFailure,noRemoteIceCandidateFailure:o.noRemoteIceCandidateFailure,setRemoteDescriptionFailure:o.setRemoteDescriptionFailure,softphoneStreamStatistics:o.streamStats};e.sendSoftphoneReport(u,{success:function(){I.info("sendSoftphoneReport success"+JSON.stringify(u)).sendInternalLogToServer()},failure:function(e){I.error("sendSoftphoneReport failed.").withObject(e).sendInternalLogToServer()}});var d={AUDIO_INPUT:{packetsCount:l.map((function(e){return e.packetsCount})),packetsLost:l.map((function(e){return e.packetsLost})),audioLevel:l.map((function(e){return e.audioLevel})),jitterBufferMillis:l.map((function(e){return e.jitterBufferMillis}))},AUDIO_OUTPUT:{packetsCount:p.map((function(e){return e.packetsCount})),packetsLost:p.map((function(e){return e.packetsLost})),audioLevel:p.map((function(e){return e.audioLevel})),jitterBufferMillis:p.map((function(e){return e.jitterBufferMillis})),roundTripTimeMillis:p.map((function(e){return e.roundTripTimeMillis}))}},f=n(n({},u),{},{softphoneStreamPerSecondStatistics:d,iceConnectionsLost:o.iceConnectionsLost,iceConnectionsFailed:o.iceConnectionsFailed||null,peerConnectionFailed:o.peerConnectionFailed||null,rtcJsVersion:o.rtcJsVersion||null,consecutiveNoAudioInputPackets:h,consecutiveLowInputAudioLevel:g,consecutiveNoAudioOutputPackets:m,consecutiveLowOutputAudioLevel:v,audioInputConnectedDurationSeconds:y,ccpMediaReadyLatencyMillis:0,contactSubtype:e.getContactSubtype(),earlyGumEnabled:b,earlyGumWorked:E,vdiPlatform:S||null,streamJsVersion:r.version});r.publishSoftphoneReport({contactId:e.getContactId(),ccpVersion:t.ccpVersion,report:f}),I.info("sent TelemetryCallReport "+JSON.stringify(f)).sendInternalLogToServer()}(e,o,re(d,s),re(f,c)),z(e)},ne=function(e,t,n,r,o,i,a){this.softphoneStreamType=r,this.timestamp=e,this.packetsLost=t,this.packetsCount=n,this.audioLevel=o,this.jitterBufferMillis=i,this.roundTripTimeMillis=a},re=function(e,t){return new ne((e=e||{}).timestamp,e.packetsLost,e.packetsCount,t,e.audioLevel)},oe=function(e){this._originalLogger=e;var t=this;this._tee=function(e,n){return function(){var e=Array.prototype.slice.call(arguments[0]),o="";return e.forEach((function(){o+=" %s"})),n.apply(t._originalLogger,[r.LogComponent.SOFTPHONE,o].concat(e))}}};oe.prototype.debug=function(){return this._tee(1,this._originalLogger.debug)(arguments)},oe.prototype.info=function(){return this._tee(2,this._originalLogger.info)(arguments)},oe.prototype.log=function(){return this._tee(3,this._originalLogger.log)(arguments)},oe.prototype.warn=function(){return this._tee(4,this._originalLogger.warn)(arguments)},oe.prototype.error=function(){return this._tee(5,this._originalLogger.error)(arguments)},r.SoftphoneManager=O}()},344:()=>{!function(){var e=this||globalThis,t=function(){return t.cache.hasOwnProperty(arguments[0])||(t.cache[arguments[0]]=t.parse(arguments[0])),t.format.call(null,t.cache[arguments[0]],arguments)};function n(e){return Object.prototype.toString.call(e).slice(8,-1).toLowerCase()}function r(e,t){for(var n=[];t>0;n[--t]=e);return n.join("")}t.format=function(e,o){var i,a,s,c,u,l,p,d=1,f=e.length,h="",g=[];for(a=0;a<f;a++)if("string"===(h=n(e[a])))g.push(e[a]);else if("array"===h){if((c=e[a])[2])for(i=o[d],s=0;s<c[2].length;s++){if(!i.hasOwnProperty(c[2][s]))throw t('[sprintf] property "%s" does not exist',c[2][s]);i=i[c[2][s]]}else i=c[1]?o[c[1]]:o[d++];if(/[^s]/.test(c[8])&&"number"!=n(i))throw t("[sprintf] expecting number but found %s",n(i));switch(c[8]){case"b":i=i.toString(2);break;case"c":i=String.fromCharCode(i);break;case"d":i=parseInt(i,10);break;case"e":i=c[7]?i.toExponential(c[7]):i.toExponential();break;case"f":i=c[7]?parseFloat(i).toFixed(c[7]):parseFloat(i);break;case"o":i=i.toString(8);break;case"s":i=(i=String(i))&&c[7]?i.substring(0,c[7]):i;break;case"u":i>>>=0;break;case"x":i=i.toString(16);break;case"X":i=i.toString(16).toUpperCase()}i=/[def]/.test(c[8])&&c[3]&&i>=0?"+"+i:i,l=c[4]?"0"==c[4]?"0":c[4].charAt(1):" ",p=c[6]-String(i).length,u=c[6]?r(l,p):"",g.push(c[5]?i+u:u+i)}return g.join("")},t.cache={},t.parse=function(e){for(var t=e,n=[],r=[],o=0;t;){if(null!==(n=/^[^\x25]+/.exec(t)))r.push(n[0]);else if(null!==(n=/^\x25{2}/.exec(t)))r.push("%");else{if(null===(n=/^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(t)))throw"[sprintf] huh?";if(n[2]){o|=1;var i=[],a=n[2],s=[];if(null===(s=/^([a-z_][a-z_\d]*)/i.exec(a)))throw"[sprintf] huh?";for(i.push(s[1]);""!==(a=a.substring(s[0].length));)if(null!==(s=/^\.([a-z_][a-z_\d]*)/i.exec(a)))i.push(s[1]);else{if(null===(s=/^\[(\d+)\]/.exec(a)))throw"[sprintf] huh?";i.push(s[1])}n[2]=i}else o|=2;if(3===o)throw"[sprintf] mixing positional and named placeholders is not (yet) supported";r.push(n)}t=t.substring(n[0].length)}return r},e.sprintf=t,e.vsprintf=function(e,n,r){return(r=n.slice(0)).splice(0,0,e),t.apply(null,r)}}()},431:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){for(var r=0;r<t.length;r++){var o=t[r];o.enumerable=o.enumerable||!1,o.configurable=!0,"value"in o&&(o.writable=!0),Object.defineProperty(e,n(o.key),o)}}function n(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}function r(e){return function(e){if(Array.isArray(e))return o(e)}(e)||function(e){if("undefined"!=typeof Symbol&&null!=e[Symbol.iterator]||null!=e["@@iterator"])return Array.from(e)}(e)||function(e,t){if(e){if("string"==typeof e)return o(e,t);var n={}.toString.call(e).slice(8,-1);return"Object"===n&&e.constructor&&(n=e.constructor.name),"Map"===n||"Set"===n?Array.from(e):"Arguments"===n||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?o(e,t):void 0}}(e)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function o(e,t){(null==t||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}!function(){var e=this||globalThis,n=e.connect||{};e.connect=n,e.lily=n;var o=function(){};o.prototype.send=function(e){throw new n.NotImplementedError},o.prototype.onMessage=function(e){throw new n.NotImplementedError};var i=function(){o.call(this)};(i.prototype=Object.create(o.prototype)).constructor=i,i.prototype.onMessage=function(e){},i.prototype.send=function(e){};var a=function(e,t){o.call(this),this.window=e,this.domain=t||"*"};(a.prototype=Object.create(o.prototype)).constructor=a,a.prototype.send=function(e){this.window.postMessage(e,this.domain)},a.prototype.onMessage=function(e){this.window.addEventListener("message",e)};var s=function(e,t,n){o.call(this),this.input=e,this.output=t,this.domain=n||"*"};(s.prototype=Object.create(o.prototype)).constructor=s,s.prototype.send=function(e){this.output.postMessage(e,this.domain)},s.prototype.onMessage=function(e){var t=this;this.input.addEventListener("message",(function(n){n.source===t.output&&e(n)}))};var c=function(e){o.call(this),this.port=e,this.id=n.randomId()};(c.prototype=Object.create(o.prototype)).constructor=c,c.prototype.send=function(e){this.port.postMessage(e)},c.prototype.onMessage=function(e){this.port.addEventListener("message",e)},c.prototype.getId=function(){return this.id};var u=function(e){o.call(this),this.streamMap=e?n.index(e,(function(e){return e.getId()})):{},this.messageListeners=[]};(u.prototype=Object.create(o.prototype)).constructor=u,u.prototype.send=function(e){this.getStreams().forEach((function(t){try{t.send(e)}catch(e){}}))},u.prototype.onMessage=function(e){this.messageListeners.push(e),this.getStreams().forEach((function(t){t.onMessage(e)}))},u.prototype.addStream=function(e){this.streamMap[e.getId()]=e,this.messageListeners.forEach((function(t){e.onMessage(t)}))},u.prototype.removeStream=function(e){delete this.streamMap[e.getId()]},u.prototype.getStreams=function(e){return n.values(this.streamMap)},u.prototype.getStreamForPort=function(e){return n.find(this.getStreams(),(function(t){return t.port===e}))};var l=function(e,t,o){this.name=e,this.upstream=t||new i,this.downstream=o||new i,this.downstreamBus=new n.EventBus,this.upstreamBus=new n.EventBus,this.upstream.onMessage(n.hitch(this,this._dispatchEvent,this.upstreamBus)),this.downstream.onMessage(n.hitch(this,this._dispatchEvent,this.downstreamBus)),this.active=!0,this.allowedEvents=[].concat(r(Object.entries(n.GlobalResiliencyEvents).map((function(e){return e[1]}))),[n.EventType.CONFIGURE,n.EventType.SYNCHRONIZE,n.EventType.ACKNOWLEDGE,n.EventType.LOG,n.EventType.SERVER_BOUND_INTERNAL_LOG,n.EventType.DOWNLOAD_LOG_FROM_CCP])};l.prototype.onUpstream=function(e,t){return n.assertNotNull(e,"eventName"),n.assertNotNull(t,"f"),n.assertTrue(n.isFunction(t),"f must be a function"),this.upstreamBus.subscribe(e,t)},l.prototype.onAllUpstream=function(e){return n.assertNotNull(e,"f"),n.assertTrue(n.isFunction(e),"f must be a function"),this.upstreamBus.subscribeAll(e)},l.prototype.onDownstream=function(e,t){return n.assertNotNull(e,"eventName"),n.assertNotNull(t,"f"),n.assertTrue(n.isFunction(t),"f must be a function"),this.downstreamBus.subscribe(e,t)},l.prototype.onAllDownstream=function(e){return n.assertNotNull(e,"f"),n.assertTrue(n.isFunction(e),"f must be a function"),this.downstreamBus.subscribeAll(e)},l.prototype.sendUpstream=function(e,t){n.assertNotNull(e,"eventName"),this.upstream.send({event:e,data:t})},l.prototype.sendDownstream=function(e,t){n.assertNotNull(e,"eventName"),this.downstream.send({event:e,data:t})},l.prototype._dispatchEvent=function(e,t){var n=t.data;n.event&&e.trigger(n.event,n.data)},l.prototype.passUpstream=function(){var e=this;return function(t,r){e.active||e.allowedEvents.includes(r)?e.upstream.send({event:r,data:t}):n.getLog().debug("[GR] Conduit ".concat(e.name," has blocked event ").concat(r," from going upstream.")).sendInternalLogToServer()}},l.prototype.passDownstream=function(){var e=this;return function(t,r){e.active||e.allowedEvents.includes(r)?e.downstream.send({event:r,data:t}):n.getLog().debug("[GR] Conduit ".concat(e.name," has blocked event ").concat(r," from going downstream.")).sendInternalLogToServer()}},l.prototype.shutdown=function(){this.upstreamBus.unsubscribeAll(),this.downstreamBus.unsubscribeAll()},l.prototype.setActive=function(){n.getLog().info("[GR] Setting CCP conduit as active"),this.active=!0},l.prototype.setInactive=function(){n.getLog().info("[GR] Setting CCP conduit as inactive"),this.active=!1};var p=function(e,t,n,r){l.call(this,e,new s(t,n.contentWindow,r||"*"),null)};(p.prototype=Object.create(l.prototype)).constructor=p;var d=function(){return e=function e(t,n,r){!function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}(this,e);var o=new URL(r).origin;this.activeRegionUrl=o,this.conduits=n.map((function(e){var n=new p(e.src,t,e);n.iframe=e;var r=new URL(e.src).origin;return n.name=r,n})),this.setActiveConduit(o)},(r=[{key:"onUpstream",value:function(e,t){var n=this.conduits.map((function(n){return n.onUpstream(e,t)}));return{unsubscribe:function(){return n.forEach((function(e){return e.unsubscribe()}))}}}},{key:"onAllUpstream",value:function(e){var t=this.conduits.map((function(t){return t.onAllUpstream(e)}));return{unsubscribe:function(){return t.forEach((function(e){return e.unsubscribe()}))}}}},{key:"onDownstream",value:function(e,t){var n=this.conduits.map((function(n){return n.onDownstream(e,t)}));return{unsubscribe:function(){return n.forEach((function(e){return e.unsubscribe()}))}}}},{key:"onAllDownstream",value:function(e){var t=this.conduits.map((function(t){return t.onAllDownstream(e)}));return{unsubscribe:function(){return t.forEach((function(e){return e.unsubscribe()}))}}}},{key:"sendUpstream",value:function(e,t){this.conduits.forEach((function(n){n.sendUpstream(e,t)}))}},{key:"sendDownstream",value:function(e,t){this.conduits.forEach((function(n){n.sendDownstream(e,t)}))}},{key:"relayUpstream",value:function(e){var t=this;this.conduits.forEach((function(r){r.onUpstream(e,(function(o){var i=t.getOtherConduit(r);i.sendUpstream(e,o),n.getLog().info("Relayed event ".concat(e," from ").concat(r.name," to ").concat(i.name," shared worker")).withObject({data:o}).sendInternalLogToServer()}))}))}},{key:"getAllConduits",value:function(){return this.conduits}},{key:"setActiveConduit",value:function(e){var t=this;this.conduits.find((function(t){return t.name===e}))?(this.conduits.forEach((function(n){n.name===e&&(t.activeRegionUrl=e,t.name=n.name,t.upstream=n.upstream,t.downstream=n.downstream,t.upstreamBus=n.upstreamBus,t.downstreamBus=n.downstreamBus)})),n.getLog().info("[GR] Switched to active conduit ".concat(this.getActiveConduit().name)).sendInternalLogToServer()):n.getLog().error("[GR] No conduit found with the given ccpUrl: ".concat(e)).sendInternalLogToServer()}},{key:"getActiveConduit",value:function(){var e=this;return this.conduits.find((function(t){return t.name===e.activeRegionUrl}))}},{key:"getInactiveConduit",value:function(){var e=this;return this.conduits.find((function(t){return t.name!==e.activeRegionUrl}))}},{key:"getOtherConduit",value:function(e){return this.conduits.find((function(t){return e.name!==t.name}))}},{key:"getConduitByRegion",value:function(e){return this.conduits.find((function(t){return t.region===e}))}},{key:"getConduitByName",value:function(e){return this.conduits.find((function(t){return t.name===e}))}}])&&t(e.prototype,r),o&&t(e,o),Object.defineProperty(e,"prototype",{writable:!1}),e;var e,r,o}();n.Stream=o,n.NullStream=i,n.WindowStream=a,n.WindowIOStream=s,n.PortStream=c,n.StreamMultiplexer=u,n.Conduit=l,n.IFrameConduit=p,n.GRProxyIframeConduit=d}()},830:()=>{!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t;var n=function(e,n){t.assertNotNull(e,"fromState"),t.assertNotNull(n,"toState"),this.fromState=e,this.toState=n};n.prototype.getAssociations=function(e){throw t.NotImplementedError()},n.prototype.getFromState=function(){return this.fromState},n.prototype.getToState=function(){return this.toState};var r=function(e,r,o){t.assertNotNull(e,"fromState"),t.assertNotNull(r,"toState"),t.assertNotNull(o,"associations"),n.call(this,e,r),this.associations=o};(r.prototype=Object.create(n.prototype)).constructor=r,r.prototype.getAssociations=function(e){return this.associations};var o=function(e,r,o){t.assertNotNull(e,"fromState"),t.assertNotNull(r,"toState"),t.assertNotNull(o,"closure"),t.assertTrue(t.isFunction(o),"closure must be a function"),n.call(this,e,r),this.closure=o};(o.prototype=Object.create(n.prototype)).constructor=o,o.prototype.getAssociations=function(e){return this.closure(e,this.getFromState(),this.getToState())};var i=function(){this.fromMap={}};i.ANY="<<any>>",i.prototype.assoc=function(e,t,n){var i=this;if(!e)throw new Error("fromStateObj is not defined.");if(!t)throw new Error("toStateObj is not defined.");if(!n)throw new Error("assocObj is not defined.");return e instanceof Array?e.forEach((function(e){i.assoc(e,t,n)})):t instanceof Array?t.forEach((function(t){i.assoc(e,t,n)})):"function"==typeof n?this._addAssociation(new o(e,t,n)):n instanceof Array?this._addAssociation(new r(e,t,n)):this._addAssociation(new r(e,t,[n])),this},i.prototype.getAssociations=function(e,n,r){t.assertNotNull(n,"fromState"),t.assertNotNull(r,"toState");var o=[],a=this.fromMap[i.ANY]||{},s=this.fromMap[n]||{};return o=(o=o.concat(this._getAssociationsFromMap(a,e,n,r))).concat(this._getAssociationsFromMap(s,e,n,r))},i.prototype._addAssociation=function(e){var t=this.fromMap[e.getFromState()];t||(t=this.fromMap[e.getFromState()]={});var n=t[e.getToState()];n||(n=t[e.getToState()]=[]),n.push(e)},i.prototype._getAssociationsFromMap=function(e,t,n,r){return(e[i.ANY]||[]).concat(e[r]||[]).reduce((function(e,n){return e.concat(n.getAssociations(t))}),[])},t.EventGraph=i}()},60:()=>{function e(){"use strict";e=function(){return n};var t,n={},r=Object.prototype,o=r.hasOwnProperty,a=Object.defineProperty||function(e,t,n){e[t]=n.value},s="function"==typeof Symbol?Symbol:{},c=s.iterator||"@@iterator",u=s.asyncIterator||"@@asyncIterator",l=s.toStringTag||"@@toStringTag";function p(e,t,n){return Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}),e[t]}try{p({},"")}catch(t){p=function(e,t,n){return e[t]=n}}function d(e,t,n,r){var o=t&&t.prototype instanceof b?t:b,i=Object.create(o.prototype),s=new N(r||[]);return a(i,"_invoke",{value:R(e,n,s)}),i}function f(e,t,n){try{return{type:"normal",arg:e.call(t,n)}}catch(e){return{type:"throw",arg:e}}}n.wrap=d;var h="suspendedStart",g="suspendedYield",m="executing",v="completed",y={};function b(){}function E(){}function S(){}var C={};p(C,c,(function(){return this}));var T=Object.getPrototypeOf,I=T&&T(T(P([])));I&&I!==r&&o.call(I,c)&&(C=I);var w=S.prototype=b.prototype=Object.create(C);function A(e){["next","throw","return"].forEach((function(t){p(e,t,(function(e){return this._invoke(t,e)}))}))}function _(e,t){function n(r,a,s,c){var u=f(e[r],e,a);if("throw"!==u.type){var l=u.arg,p=l.value;return p&&"object"==i(p)&&o.call(p,"__await")?t.resolve(p.__await).then((function(e){n("next",e,s,c)}),(function(e){n("throw",e,s,c)})):t.resolve(p).then((function(e){l.value=e,s(l)}),(function(e){return n("throw",e,s,c)}))}c(u.arg)}var r;a(this,"_invoke",{value:function(e,o){function i(){return new t((function(t,r){n(e,o,t,r)}))}return r=r?r.then(i,i):i()}})}function R(e,n,r){var o=h;return function(i,a){if(o===m)throw Error("Generator is already running");if(o===v){if("throw"===i)throw a;return{value:t,done:!0}}for(r.method=i,r.arg=a;;){var s=r.delegate;if(s){var c=O(s,r);if(c){if(c===y)continue;return c}}if("next"===r.method)r.sent=r._sent=r.arg;else if("throw"===r.method){if(o===h)throw o=v,r.arg;r.dispatchException(r.arg)}else"return"===r.method&&r.abrupt("return",r.arg);o=m;var u=f(e,n,r);if("normal"===u.type){if(o=r.done?v:g,u.arg===y)continue;return{value:u.arg,done:r.done}}"throw"===u.type&&(o=v,r.method="throw",r.arg=u.arg)}}}function O(e,n){var r=n.method,o=e.iterator[r];if(o===t)return n.delegate=null,"throw"===r&&e.iterator.return&&(n.method="return",n.arg=t,O(e,n),"throw"===n.method)||"return"!==r&&(n.method="throw",n.arg=new TypeError("The iterator does not provide a '"+r+"' method")),y;var i=f(o,e.iterator,n.arg);if("throw"===i.type)return n.method="throw",n.arg=i.arg,n.delegate=null,y;var a=i.arg;return a?a.done?(n[e.resultName]=a.value,n.next=e.nextLoc,"return"!==n.method&&(n.method="next",n.arg=t),n.delegate=null,y):a:(n.method="throw",n.arg=new TypeError("iterator result is not an object"),n.delegate=null,y)}function L(e){var t={tryLoc:e[0]};1 in e&&(t.catchLoc=e[1]),2 in e&&(t.finallyLoc=e[2],t.afterLoc=e[3]),this.tryEntries.push(t)}function k(e){var t=e.completion||{};t.type="normal",delete t.arg,e.completion=t}function N(e){this.tryEntries=[{tryLoc:"root"}],e.forEach(L,this),this.reset(!0)}function P(e){if(e||""===e){var n=e[c];if(n)return n.call(e);if("function"==typeof e.next)return e;if(!isNaN(e.length)){var r=-1,a=function n(){for(;++r<e.length;)if(o.call(e,r))return n.value=e[r],n.done=!1,n;return n.value=t,n.done=!0,n};return a.next=a}}throw new TypeError(i(e)+" is not iterable")}return E.prototype=S,a(w,"constructor",{value:S,configurable:!0}),a(S,"constructor",{value:E,configurable:!0}),E.displayName=p(S,l,"GeneratorFunction"),n.isGeneratorFunction=function(e){var t="function"==typeof e&&e.constructor;return!!t&&(t===E||"GeneratorFunction"===(t.displayName||t.name))},n.mark=function(e){return Object.setPrototypeOf?Object.setPrototypeOf(e,S):(e.__proto__=S,p(e,l,"GeneratorFunction")),e.prototype=Object.create(w),e},n.awrap=function(e){return{__await:e}},A(_.prototype),p(_.prototype,u,(function(){return this})),n.AsyncIterator=_,n.async=function(e,t,r,o,i){void 0===i&&(i=Promise);var a=new _(d(e,t,r,o),i);return n.isGeneratorFunction(t)?a:a.next().then((function(e){return e.done?e.value:a.next()}))},A(w),p(w,l,"Generator"),p(w,c,(function(){return this})),p(w,"toString",(function(){return"[object Generator]"})),n.keys=function(e){var t=Object(e),n=[];for(var r in t)n.push(r);return n.reverse(),function e(){for(;n.length;){var r=n.pop();if(r in t)return e.value=r,e.done=!1,e}return e.done=!0,e}},n.values=P,N.prototype={constructor:N,reset:function(e){if(this.prev=0,this.next=0,this.sent=this._sent=t,this.done=!1,this.delegate=null,this.method="next",this.arg=t,this.tryEntries.forEach(k),!e)for(var n in this)"t"===n.charAt(0)&&o.call(this,n)&&!isNaN(+n.slice(1))&&(this[n]=t)},stop:function(){this.done=!0;var e=this.tryEntries[0].completion;if("throw"===e.type)throw e.arg;return this.rval},dispatchException:function(e){if(this.done)throw e;var n=this;function r(r,o){return s.type="throw",s.arg=e,n.next=r,o&&(n.method="next",n.arg=t),!!o}for(var i=this.tryEntries.length-1;i>=0;--i){var a=this.tryEntries[i],s=a.completion;if("root"===a.tryLoc)return r("end");if(a.tryLoc<=this.prev){var c=o.call(a,"catchLoc"),u=o.call(a,"finallyLoc");if(c&&u){if(this.prev<a.catchLoc)return r(a.catchLoc,!0);if(this.prev<a.finallyLoc)return r(a.finallyLoc)}else if(c){if(this.prev<a.catchLoc)return r(a.catchLoc,!0)}else{if(!u)throw Error("try statement without catch or finally");if(this.prev<a.finallyLoc)return r(a.finallyLoc)}}}},abrupt:function(e,t){for(var n=this.tryEntries.length-1;n>=0;--n){var r=this.tryEntries[n];if(r.tryLoc<=this.prev&&o.call(r,"finallyLoc")&&this.prev<r.finallyLoc){var i=r;break}}i&&("break"===e||"continue"===e)&&i.tryLoc<=t&&t<=i.finallyLoc&&(i=null);var a=i?i.completion:{};return a.type=e,a.arg=t,i?(this.method="next",this.next=i.finallyLoc,y):this.complete(a)},complete:function(e,t){if("throw"===e.type)throw e.arg;return"break"===e.type||"continue"===e.type?this.next=e.arg:"return"===e.type?(this.rval=this.arg=e.arg,this.method="return",this.next="end"):"normal"===e.type&&t&&(this.next=t),y},finish:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.finallyLoc===e)return this.complete(n.completion,n.afterLoc),k(n),y}},catch:function(e){for(var t=this.tryEntries.length-1;t>=0;--t){var n=this.tryEntries[t];if(n.tryLoc===e){var r=n.completion;if("throw"===r.type){var o=r.arg;k(n)}return o}}throw Error("illegal catch attempt")},delegateYield:function(e,n,r){return this.delegate={iterator:P(e),resultName:n,nextLoc:r},"next"===this.method&&(this.arg=t),y}},n}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(e,t,n){return(t=function(e){var t=function(e,t){if("object"!=i(e)||!e)return e;var n=e[Symbol.toPrimitive];if(void 0!==n){var r=n.call(e,t||"default");if("object"!=i(r))return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===t?String:Number)(e)}(e,"string");return"symbol"==i(t)?t:t+""}(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function o(e,t,n,r,o,i,a){try{var s=e[i](a),c=s.value}catch(e){return void n(e)}s.done?t(c):Promise.resolve(c).then(r,o)}function i(e){return i="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},i(e)}!function(){var t=this||globalThis,r=t.connect||{};t.connect=r,t.lily=r;var a=navigator.userAgent,s=["bubbles","cancelBubble","cancelable","composed","data","defaultPrevented","eventPhase","isTrusted","lastEventId","origin","returnValue","timeStamp","type"];r.sprintf=t.sprintf,r.vsprintf=t.vsprintf,delete t.sprintf,delete t.vsprintf,r.HTTP_STATUS_CODES={SUCCESS:200,UNAUTHORIZED:401,ACCESS_DENIED:403,TOO_MANY_REQUESTS:429,INTERNAL_SERVER_ERROR:500},r.TRANSPORT_TYPES={CHAT_TOKEN:"chat_token",WEB_SOCKET:"web_socket",AGENT_DISCOVERY:"agent_discovery",WEB_RTC:"web_rtc"},r.hitch=function(){var e=Array.prototype.slice.call(arguments),t=e.shift(),n=e.shift();return r.assertNotNull(t,"scope"),r.assertNotNull(n,"method"),r.assertTrue(r.isFunction(n),"method must be a function"),function(){var r=Array.prototype.slice.call(arguments);return n.apply(t,e.concat(r))}},r.isFunction=function(e){return!!(e&&e.constructor&&e.call&&e.apply)},r.isArray=function(e){return"[object Array]"===Object.prototype.toString.call(e)},r.keys=function(e){var t=[];for(var n in r.assertNotNull(e,"map"),e)t.push(n);return t},r.values=function(e){var t=[];for(var n in r.assertNotNull(e,"map"),e)t.push(e[n]);return t},r.entries=function(e){var t=[];for(var n in e)t.push({key:n,value:e[n]});return t},r.merge=function(){var e=Array.prototype.slice.call(arguments,0),t={};return e.forEach((function(e){r.entries(e).forEach((function(e){t[e.key]=e.value}))})),t},r.now=function(){return(new Date).getTime()},r.find=function(e,t){for(var n=0;n<e.length;n++)if(t(e[n]))return e[n];return null},r.contains=function(e,t){return e instanceof Array?null!=r.find(e,(function(e){return e===t})):t in e},r.containsValue=function(e,t){return e instanceof Array?null!=r.find(e,(function(e){return e===t})):null!=r.find(r.values(e),(function(e){return e===t}))},r.randomId=function(){return r.sprintf("%s-%s",r.now(),Math.random().toString(36).slice(2))},r.makeEnum=function(e){var t={};return e.forEach((function(e){var n=e.replace(/\.?([a-z]+)_?/g,(function(e,t){return t.toUpperCase()+"_"})).replace(/_$/,"");t[n]=e})),t},r.makeNamespacedEnum=function(e,t){var n=r.makeEnum(t);return r.keys(n).forEach((function(t){n[t]=r.sprintf("%s::%s",e,n[t])})),n},r.makeGenericNamespacedEnum=function(e,t,n){var o=r.makeEnum(t);return r.keys(o).forEach((function(t){o[t]=r.sprintf("%s"+n+"%s",e,o[t])})),o},r.isChromeBrowser=function(){return-1!==a.indexOf("Chrome")},r.isFirefoxBrowser=function(){return-1!==a.indexOf("Firefox")},r.isOperaBrowser=function(){return-1!==a.indexOf("Opera")},r.isEdgeBrowser=function(){return-1!==a.indexOf("Edg")},r.getChromeBrowserVersion=function(){var e=a.substring(a.indexOf("Chrome")+7);return e?parseFloat(e):-1},r.getFirefoxBrowserVersion=function(){var e=a.substring(a.indexOf("Firefox")+8);return e?parseFloat(e):-1},r.isValidLocale=function(e){return[{id:"en_US",label:"English"},{id:"de_DE",label:"Deutsch"},{id:"es_ES",label:"Español"},{id:"fr_FR",label:"Français"},{id:"ja_JP",label:"日本語"},{id:"it_IT",label:"Italiano"},{id:"ko_KR",label:"한국어"},{id:"pt_BR",label:"Português"},{id:"zh_CN",label:"中文(简体)"},{id:"zh_TW",label:"中文(繁體)"}].map((function(e){return e.id})).includes(e)},r.getOperaBrowserVersion=function(){var e=a.indexOf("Opera"),t=-1!==a.indexOf("Version")?a.substring(e+8):a.substring(e+6);return t?parseFloat(t):-1},r.index=function(e,t){var n={};return e.forEach((function(e){n[t(e)]=e})),n},r.set=function(e){var t={};return e.forEach((function(e){t[e]=1})),t},r.relativeComplement=function(e,t){var n={};return r.keys(t).forEach((function(r){r in e||(n[r]=t[r])})),n},r.assertTrue=function(e,t){if(!e)throw new r.ValueError(t)},r.assertNotNull=function(e,t){return r.assertTrue(null!=e&&void 0!==i(e),r.sprintf("%s must be provided",t||"A value")),e},r.deepcopy=function(e){return JSON.parse(JSON.stringify(e))},r.deepcopyCrossOriginEvent=function(e){var t={};return s.forEach((function(n){try{t[n]=e[n]}catch(e){r.getLog().info("deepcopyCrossOriginEvent failed on key: ",n).sendInternalLogToServer()}})),r.deepcopy(t)},r.getBaseUrl=function(){var e=t.location;return r.sprintf("%s//%s:%s",e.protocol,e.hostname,e.port)},r.getUrlWithProtocol=function(e){var n=t.location.protocol;return e.substr(0,n.length)!==n?r.sprintf("%s//%s",n,e):e},r.isFramed=function(){try{return window.self!==window.top}catch(e){return!0}},r.hasOtherConnectedCCPs=function(){return r.numberOfConnectedCCPs>1},r.fetch=function(e,t,n,o){return o=o||5,n=n||1e3,t=t||{},new Promise((function(i,a){!function o(s){fetch(e,t).then((function(e){e.status===r.HTTP_STATUS_CODES.SUCCESS?e.json().then((function(e){return i(e)})).catch((function(){return i({})})):1!==s&&(e.status>=r.HTTP_STATUS_CODES.INTERNAL_SERVER_ERROR||e.status===r.HTTP_STATUS_CODES.TOO_MANY_REQUESTS)?setTimeout((function(){o(--s)}),n):a(e)})).catch((function(e){a(e)}))}(o)}))},r.fetchWithTimeout=function(){var t,i=(t=e().mark((function t(o,i,a,s,c){var u,l,p;return e().wrap((function(e){for(;;)switch(e.prev=e.next){case 0:if(a=a||{},i){e.next=3;break}return e.abrupt("return",r.fetch(o,a,s,c));case 3:return u=new AbortController,l=setTimeout((function(){return u.abort()}),i),e.next=7,r.fetch(o,n(n({},a),{},{signal:u.signal}),s,c);case 7:return p=e.sent,clearTimeout(l),e.abrupt("return",p);case 10:case"end":return e.stop()}}),t)})),function(){var e=this,n=arguments;return new Promise((function(r,i){var a=t.apply(e,n);function s(e){o(a,r,i,s,c,"next",e)}function c(e){o(a,r,i,s,c,"throw",e)}s(void 0)}))});return function(e,t,n,r,o){return i.apply(this,arguments)}}(),r.backoff=function(e,n,o,i){r.assertTrue(r.isFunction(e),"func must be a Function");var a=this;e({success:function(e){i&&i.success&&i.success(e)},failure:function(r,s){if(o>0){var c=2*n*Math.random();t.setTimeout((function(){a.backoff(e,2*c,--o,i)}),c)}else i&&i.failure&&i.failure(r,s)}})},r.publishMetric=function(e){r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.EventType.CLIENT_METRIC,data:e})},r.publishSoftphoneStats=function(e){r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.EventType.SOFTPHONE_STATS,data:e})},r.publishSoftphoneReport=function(e){r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.EventType.SOFTPHONE_REPORT,data:e})},r.publishClickStreamData=function(e){r.core.getUpstream().sendUpstream(r.EventType.BROADCAST,{event:r.EventType.CLICK_STREAM_DATA,data:e})},r.publishClientSideLogs=function(e){r.core.getEventBus().trigger(r.EventType.CLIENT_SIDE_LOGS,e)},r.addNamespaceToLogs=function(e){["log","error","warn","info","debug"].forEach((function(t){var n=window.console[t];window.console[t]=function(){var t=Array.from(arguments);t.unshift("[".concat(e,"]")),n.apply(window.console,t)}}))},r.PopupManager=function(){},r.PopupManager.prototype.open=function(e,t,n){var r=null;if(n){var o=n.height||578,i=n.width||433,a=n.top||0,s=n.left||0;(r=window.open("",t,"width="+i+", height="+o+", top="+a+", left="+s)).location!==e&&(r=window.open(e,t,"width="+i+", height="+o+", top="+a+", left="+s))}else(r=window.open("",t)).location!==e&&(r=window.open(e,t));return r},r.PopupManager.prototype.clear=function(e){var n=this._getLocalStorageKey(e);t.localStorage.removeItem(n)},r.PopupManager.prototype._getLastOpenedTimestamp=function(e){var n=this._getLocalStorageKey(e),r=t.localStorage.getItem(n);return r?parseInt(r,10):0},r.PopupManager.prototype._setLastOpenedTimestamp=function(e,n){var r=this._getLocalStorageKey(e);t.localStorage.setItem(r,""+n)},r.PopupManager.prototype._getLocalStorageKey=function(e){return"connectPopupManager::"+e};var c=r.makeEnum(["granted","denied","default"]);r.NotificationManager=function(){this.queue=[],this.permission=c.DEFAULT},r.NotificationManager.prototype.requestPermission=function(){var e=this;"Notification"in t?t.Notification.permission===c.DENIED?(r.getLog().warn("The user has requested to not receive notifications.").sendInternalLogToServer(),this.permission=c.DENIED):this.permission!==c.GRANTED&&t.Notification.requestPermission().then((function(t){e.permission=t,t===c.GRANTED?e._showQueued():e.queue=[]})):(r.getLog().warn("This browser doesn't support notifications.").sendInternalLogToServer(),this.permission=c.DENIED)},r.NotificationManager.prototype.show=function(e,t){if(this.permission===c.GRANTED)return this._showImpl({title:e,options:t});if(this.permission===c.DENIED)r.getLog().warn("Unable to show notification.").sendInternalLogToServer().withObject({title:e,options:t});else{var n={title:e,options:t};r.getLog().warn("Deferring notification until user decides to allow or deny.").withObject(n).sendInternalLogToServer(),this.queue.push(n)}},r.NotificationManager.prototype._showQueued=function(){var e=this,t=this.queue.map((function(t){return e._showImpl(t)}));return this.queue=[],t},r.NotificationManager.prototype._showImpl=function(e){var n=new t.Notification(e.title,e.options);return e.options.clicked&&(n.onclick=function(){e.options.clicked.call(n)}),n},r.ValueError=function(){var e=Array.prototype.slice.call(arguments,0),t=e.shift(),n=new Error(r.vsprintf(t,e));return Object.setPrototypeOf(n,r.ValueError.prototype),n},Object.setPrototypeOf(r.ValueError.prototype,Error.prototype),Object.setPrototypeOf(r.ValueError,Error),r.ValueError.prototype.name="ValueError",r.NotImplementedError=function(){var e=Array.prototype.slice.call(arguments,0),t=e.shift(),n=new Error(r.vsprintf(t,e));return Object.setPrototypeOf(n,r.NotImplementedError.prototype),n},Object.setPrototypeOf(r.NotImplementedError.prototype,Error.prototype),Object.setPrototypeOf(r.NotImplementedError,Error),r.NotImplementedError.prototype.name="NotImplementedError",r.StateError=function(){var e=Array.prototype.slice.call(arguments,0),t=e.shift(),n=new Error(r.vsprintf(t,e));return Object.setPrototypeOf(n,r.StateError.prototype),n},Object.setPrototypeOf(r.StateError.prototype,Error.prototype),Object.setPrototypeOf(r.StateError,Error),r.StateError.prototype.name="StateError",r.VoiceIdError=function(e,t,n){var r={};return r.type=e,r.message=t,r.stack=Error(t).stack,r.err=n,r},r.isCCP=function(){return!!r.core.upstream&&"ConnectSharedWorkerConduit"===r.core.getUpstream().name},r.isSharedWorker=function(){return r.worker&&!!r.worker.clientEngine},r.isCRM=function(){return!!r.core.upstream&&(r.core.getUpstream()instanceof r.IFrameConduit||r.core.getUpstream()instanceof r.GRProxyIframeConduit)},r.isActiveConduit=function(e){var t=r.core.getUpstream();return t instanceof r.GRProxyIframeConduit?e.name===t.activeRegionUrl:(r.getLog().debug("connect.isActiveConduit is called but there is no GR proxy conduit").sendInternalLogToServer(),!0)}}()},354:()=>{function e(t){return e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},e(t)}function t(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter((function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable}))),n.push.apply(n,r)}return n}function n(e){for(var n=1;n<arguments.length;n++){var o=null!=arguments[n]?arguments[n]:{};n%2?t(Object(o),!0).forEach((function(t){r(e,t,o[t])})):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(o)):t(Object(o)).forEach((function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(o,t))}))}return e}function r(t,n,r){return(n=function(t){var n=function(t,n){if("object"!=e(t)||!t)return t;var r=t[Symbol.toPrimitive];if(void 0!==r){var o=r.call(t,n||"default");if("object"!=e(o))return o;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===n?String:Number)(t)}(t,"string");return"symbol"==e(n)?n:n+""}(n))in t?Object.defineProperty(t,n,{value:r,enumerable:!0,configurable:!0,writable:!0}):t[n]=r,t}!function(){var e=this||globalThis,t=e.connect||{};e.connect=t,e.lily=t,t.worker={};var r="LADS.GetAgentFailoverConfiguration",o={createTaskContact:"createTaskContact",createOutboundContact:"createOutboundContact",createTemplatedTask:"createTemplatedTask"},i=function(){this.topicMasterMap={}};i.prototype.getMaster=function(e){return t.assertNotNull(e,"topic"),this.topicMasterMap[e]||null},i.prototype.setMaster=function(e,n){t.assertNotNull(e,"topic"),t.assertNotNull(n,"id"),this.topicMasterMap[e]=n},i.prototype.removeMaster=function(e){t.assertNotNull(e,"id");var n=this;t.entries(this.topicMasterMap).filter((function(t){return t.value===e})).forEach((function(e){delete n.topicMasterMap[e.key]}))};var a=function(e){t.ClientBase.call(this),this.conduit=e};(a.prototype=Object.create(t.ClientBase.prototype)).constructor=a,a.prototype._callImpl=function(e,n,r){var o=this,i=(new Date).getTime();t.containsValue(t.AgentAppClientMethods,e)?t.core.getAgentAppClient()._callImpl(e,n,{success:function(t){o._recordAPILatency(e,i,n),r.success(t)},failure:function(t){o._recordAPILatency(e,i,n,t),r.failure(t)}}):t.containsValue(t.TaskTemplatesClientMethods,e)?t.core.getTaskTemplatesClient()._callImpl(e,n,{success:function(t){o._recordAPILatency(e,i,n),r.success(t)},failure:function(t){o._recordAPILatency(e,i,n,t),r.failure(t)}}):t.core.getClient()._callImpl(e,n,{success:function(t,a){o._recordAPILatency(e,i,n),r.success(t,a)},failure:function(t,a){o._recordAPILatency(e,i,n,t),r.failure(t,a)},authFailure:function(t,a){o._recordAPILatency(e,i,n,t),r.authFailure()},accessDenied:function(t,a){o._recordAPILatency(e,i,n,t),r.accessDenied&&r.accessDenied()}})},a.prototype._recordAPILatency=function(e,t,n,r){var o=(new Date).getTime()-t;this._sendAPIMetrics(e,o,n,r)},a.prototype._sendAPIMetrics=function(e,r,i,a){var s={name:e,time:r,error:a,error5xx:0},c=[{name:"Category",value:"API"}],u=a&&a.statusCode||200,l=a&&a.retryStatus||t.RetryStatus.NONE,p=[{name:"HttpStatusCode",value:u},{name:"HttpGenericStatusCode",value:"".concat(u.toString().charAt(0),"XX")},{name:"RetryStatus",value:l}];if("5"===u.toString().charAt(0)&&(s.error5xx=1),"5"===u.toString().charAt(0)?s.fault=1:"2"===u.toString().charAt(0)&&(s.fault=0),o[e]&&i&&i.relatedContactId){var d={name:"".concat(e,"WithRelatedContactId"),time:s.time,error:s.error,error5xx:s.error5xx};this.conduit.sendDownstream(t.EventType.API_METRIC,n(n({},d),{},{dimensions:c,optionalDimensions:p}))}this.conduit.sendDownstream(t.EventType.API_METRIC,n(n({},s),{},{dimensions:c,optionalDimensions:p}))};var s=function(){var n=this;this.multiplexer=new t.StreamMultiplexer,this.conduit=new t.Conduit("AmazonConnectSharedWorker",null,this.multiplexer),this.client=new a(this.conduit),this.timeout=null,this.agent=null,this.nextToken=null,this.initData={},this.portConduitMap={},this.streamMapByTabId={},this.masterCoord=new i,this.logsBuffer=[],this.suppress=!1,this.forceOffline=!1,this.longPollingOptions={allowLongPollingShadowMode:!1,allowLongPollingWebsocketOnlyMode:!1},this.drPollingUrl=null,this.thisArn=null,this.otherArn=null,this.pendingFailover=null;var r=null;t.rootLogger=new t.DownstreamConduitLogger(this.conduit),this.conduit.onDownstream(t.EventType.SEND_LOGS,(function(e){t.getLog().pushLogsDownstream(e),n.logsBuffer=n.logsBuffer.concat(e),n.logsBuffer.length>400&&n.handleSendLogsRequest(n.logsBuffer)})),this.conduit.onDownstream(t.DisasterRecoveryEvents.SUPPRESS,(function(e){t.getLog().debug("[Disaster Recovery] Setting Suppress to %s",e.suppress).sendInternalLogToServer(),n.suppress=e.suppress||!1,n.suppress||(n.forceOffline=!1),(void 0===e.shouldSendFailoverDownstream||e.shouldSendFailoverDownstream)&&n.conduit.sendDownstream(t.DisasterRecoveryEvents.FAILOVER,{isPrimary:!n.suppress})})),this.conduit.onDownstream(t.DisasterRecoveryEvents.FORCE_OFFLINE,(function(e){t.getLog().debug("[Disaster Recovery] Setting FORCE_OFFLINE to %s",e.offline).sendInternalLogToServer(),n.forceOffline||(n.pendingFailover=!1,n.conduit.sendDownstream(t.DisasterRecoveryEvents.FAILOVER,{isPrimary:!1,nextActiveArn:e.nextActiveArn})),n.forceOffline=e.offline||!1})),t.DisasterRecoveryEvents.INIT_DR_POLLING&&this.conduit.onDownstream(t.DisasterRecoveryEvents.INIT_DR_POLLING,(function(e){var r=t.getLog();n.drPollingUrl?(r.debug("[Disaster Recovery] Adding new CCP to active region polling for instance ".concat(e.instanceArn)).sendInternalLogToServer(),n.pollForActiveRegion(!0,!1)):(r.info("[Disaster Recovery] Initializing active region polling for instance ".concat(e.instanceArn)).sendInternalLogToServer(),n.thisArn=e.instanceArn,n.otherArn=e.otherArn,n.getPresignedDiscoveryUrl().then((function(e){n.drPollingUrl=e,n.pollForActiveRegion(!0,!0)}),(function(t){r.error("[Disaster Recovery] Failed to get presigned URL for instance ".concat(e.instanceArn,"; suppressing contacts")).withException(t).sendInternalLogToServer(),n.suppress=!0})))})),this.conduit.onDownstream(t.EventType.CONFIGURE,(function(o){console.log("@@@ configure event handler",o);try{o.authToken&&o.authToken!==n.initData.authToken&&(n.initData=o,t.core.init(o),o.longPollingOptions&&("boolean"==typeof o.longPollingOptions.allowLongPollingShadowMode&&(n.longPollingOptions.allowLongPollingShadowMode=o.longPollingOptions.allowLongPollingShadowMode),"boolean"==typeof o.longPollingOptions.allowLongPollingWebsocketOnlyMode&&(n.longPollingOptions.allowLongPollingWebsocketOnlyMode=o.longPollingOptions.allowLongPollingWebsocketOnlyMode)),r?t.getLog().info("Not Initializing a new WebsocketManager instance, since one already exists").sendInternalLogToServer():(t.getLog().info("Creating a new Websocket connection for CCP").sendInternalLogToServer(),t.WebSocketManager.setGlobalConfig({loggerConfig:{logger:t.getLog(),advancedLogWriter:"info",level:10}}),(r=t.WebSocketManager.create()).onInitFailure((function(){n.conduit.sendDownstream(t.WebSocketEvents.INIT_FAILURE)})),r.onConnectionOpen((function(e){n.conduit.sendDownstream(t.WebSocketEvents.CONNECTION_OPEN,e)})),r.onConnectionClose((function(e){n.conduit.sendDownstream(t.WebSocketEvents.CONNECTION_CLOSE,e)})),r.onConnectionGain((function(){n.conduit.sendDownstream(t.AgentEvents.WEBSOCKET_CONNECTION_GAINED),n.conduit.sendDownstream(t.WebSocketEvents.CONNECTION_GAIN)})),r.onConnectionLost((function(e){n.conduit.sendDownstream(t.AgentEvents.WEBSOCKET_CONNECTION_LOST,e),n.conduit.sendDownstream(t.WebSocketEvents.CONNECTION_LOST,e)})),r.onSubscriptionUpdate((function(e){n.conduit.sendDownstream(t.WebSocketEvents.SUBSCRIPTION_UPDATE,e)})),r.onSubscriptionFailure((function(e){n.conduit.sendDownstream(t.WebSocketEvents.SUBSCRIPTION_FAILURE,e)})),r.onAllMessage((function(e){n.conduit.sendDownstream(t.WebSocketEvents.ALL_MESSAGE,e)})),n.conduit.onDownstream(t.WebSocketEvents.SEND,(function(e){r.sendMessage(e)})),n.conduit.onDownstream(t.WebSocketEvents.SUBSCRIBE,(function(e){r.subscribeTopics(e)})),r.init(t.hitch(n,n.getWebSocketUrl)).then((function(r){try{if(r&&!r.webSocketConnectionFailed)t.getLog().info("Kicking off agent polling").sendInternalLogToServer(),n.pollForAgent(),t.getLog().info("Kicking off config polling").sendInternalLogToServer(),n.pollForAgentConfiguration({repeatForever:!0}),t.getLog().info("Kicking off auth token polling").sendInternalLogToServer(),e.setInterval(t.hitch(n,n.checkAuthToken),3e5);else if(!t.webSocketInitFailed){var o=t.WebSocketEvents.INIT_FAILURE;throw n.conduit.sendDownstream(o),t.webSocketInitFailed=!0,new Error(o)}}catch(e){t.getLog().error("WebSocket failed to initialize").withException(e).sendInternalLogToServer()}}))))}catch(e){console.error("@@@ error",e)}})),this.conduit.onDownstream(t.EventType.TERMINATE,(function(){n.handleSendLogsRequest(n.logsBuffer),t.core.terminate(),n.conduit.sendDownstream(t.EventType.TERMINATED)})),this.conduit.onDownstream(t.EventType.SYNCHRONIZE,(function(){n.conduit.sendDownstream(t.EventType.ACKNOWLEDGE)})),this.conduit.onDownstream(t.EventType.BROADCAST,(function(e){n.conduit.sendDownstream(e.event,e.data)})),e.onconnect=function(e){var r=e.ports[0],o=new t.PortStream(r);n.multiplexer.addStream(o),r.start();var i=new t.Conduit(o.getId(),null,o);i.sendDownstream(t.EventType.ACKNOWLEDGE,{id:o.getId()}),n.portConduitMap[o.getId()]=i,n.conduit.sendDownstream(t.EventType.UPDATE_CONNECTED_CCPS,{length:Object.keys(n.portConduitMap).length}),null!==n.agent&&n.updateAgent(),i.onDownstream(t.EventType.API_REQUEST,t.hitch(n,n.handleAPIRequest,i)),i.onDownstream(t.EventType.MASTER_REQUEST,t.hitch(n,n.handleMasterRequest,i,o.getId())),i.onDownstream(t.EventType.RELOAD_AGENT_CONFIGURATION,t.hitch(n,n.pollForAgentConfiguration)),i.onDownstream(t.EventType.TAB_ID,t.hitch(n,n.handleTabIdEvent,o)),i.onDownstream(t.EventType.CLOSE,t.hitch(n,n.handleCloseEvent,o))}};s.prototype.pollForActiveRegion=function(o,i){var a=this,s=t.getLog();if(!a.drPollingUrl)throw new t.StateError("[Disaster Recovery] Tried to poll for active region without first initializing DR polling in the worker.");s.debug("[Disaster Recovery] Polling for failover with presigned URL for instance ".concat(a.thisArn)).sendInternalLogToServer();var c=(new Date).getTime();return t.fetchWithTimeout(a.drPollingUrl,1e4).catch((function(e){if(e.status){if(a.client._recordAPILatency(r,c,{statusCode:e.status}),[t.HTTP_STATUS_CODES.ACCESS_DENIED,t.HTTP_STATUS_CODES.UNAUTHORIZED].includes(e.status))return s.info("[Disaster Recovery] Active region polling failed; trying to get a new URL for polling.").withObject(e).sendInternalLogToServer(),a.getPresignedDiscoveryUrl().then((function(e){a.drPollingUrl=e})).then((function(){return c=(new Date).getTime(),t.fetchWithTimeout(a.drPollingUrl,1e4)}));var n="[Disaster Recovery] Failed to poll for failover for instance ".concat(a.thisArn,", ")+"received unexpected response code ".concat(e.status);throw s.error(n).withObject(e).sendInternalLogToServer(),new Error(n)}throw n="[Disaster Recovery] Failed to poll for failover for instance ".concat(a.thisArn,", request timed out or aborted"),a.client._recordAPILatency(r,c,{statusCode:-1}),s.error(n).withObject(e).sendInternalLogToServer(),new Error(n)})).then((function(e){if(a.client._recordAPILatency(r,c),"boolean"==typeof e.TerminateActiveContacts){var n=!e.TerminateActiveContacts;if(e.InstanceArn)if(s.debug("[Disaster Recovery] Successfully polled for active region. Primary instance ARN is ".concat(e.InstanceArn," ")+"and soft failover is ".concat(n?"enabled":"disabled")).sendInternalLogToServer(),a.thisArn===e.InstanceArn&&!a.suppress&&o)s.debug("[Disaster Recovery] Instance ".concat(a.thisArn," is being set to primary")).sendInternalLogToServer(),a.conduit.sendDownstream(t.DisasterRecoveryEvents.FAILOVER,{nextActiveArn:e.InstanceArn});else if(a.otherArn===e.InstanceArn){if(!n||i||!o||a.suppress&&!a.pendingFailover||a.conduit.sendDownstream(t.DisasterRecoveryEvents.FAILOVER,{nextActiveArn:a.thisArn}),!a.suppress){a.suppress=!0;var u=n&&!i;u?(a.pendingFailover=!0,s.debug("[Disaster Recovery] Instance ".concat(a.thisArn," will be set to stand-by using soft failover")).sendInternalLogToServer()):s.debug("[Disaster Recovery] Instance ".concat(a.thisArn," is being set to stand-by immediately")).sendInternalLogToServer(),a.conduit.sendDownstream(t.DisasterRecoveryEvents.FORCE_OFFLINE,{softFailover:u,nextActiveArn:e.InstanceArn})}}else[a.thisArn,a.otherArn].includes(e.InstanceArn)||s.error("[Disaster Recovery] The current primary instance in this agent's failover group ".concat(e.InstanceArn," ")+"doesn't match this instance ".concat(a.thisArn," or the other instance ").concat(a.otherArn)).sendInternalLogToServer();else s.error("[Disaster Recovery] DR polling response did not contain a truthy active instance ARN.").withObject(e).sendInternalLogToServer()}else s.error("[Disaster Recovery] DR polling response did not contain a valid value for TerminateActiveContacts.").withObject(e).sendInternalLogToServer()})).catch((function(e){e.status&&a.client._recordAPILatency(r,c,n(n({},e),{},{statusCode:e.status})),s.error("[Disaster Recovery] Active region polling failed for instance ".concat(a.thisArn,".")).withObject(e).sendInternalLogToServer()})).finally((function(){!i&&o||e.setTimeout(t.hitch(a,a.pollForActiveRegion),6e4)}))},s.prototype.getPresignedDiscoveryUrl=function(){var e=this,n=this;return new Promise((function(r,o){t.getLog().info("[Disaster Recovery] Getting presigned URL for instance ".concat(n.thisArn)).sendInternalLogToServer(),e.client.call(t.ClientMethods.CREATE_TRANSPORT,{transportType:t.TRANSPORT_TYPES.AGENT_DISCOVERY},{success:function(e){e&&e.agentDiscoveryTransport&&e.agentDiscoveryTransport.presignedUrl?(t.getLog().info("getPresignedDiscoveryUrl succeeded").sendInternalLogToServer(),r(e.agentDiscoveryTransport.presignedUrl)):(t.getLog().info("getPresignedDiscoveryUrl received empty/invalid data").withObject(e).sendInternalLogToServer(),o(Error("getPresignedDiscoveryUrl received empty/invalid data")))},failure:function(e,r){t.getLog().error("[Disaster Recovery] Failed to get presigned URL for instance ".concat(n.thisArn)).withException(e).withObject(r).sendInternalLogToServer(),o(new Error("Failed to get presigned URL"))},authFailure:function(){t.hitch(n,n.handleAuthFail)(),o(new Error("Encountered auth failure when getting presigned URL"))},accessDenied:function(){t.hitch(n,n.handleAccessDenied)(),o(new Error("Encountered access denied when getting presigned URL"))}})}))},s.prototype.pollForAgent=function(){var n=this,r=t.hitch(n,n.handlePollingAuthFail);this.client.call(t.ClientMethods.GET_AGENT_SNAPSHOT,{nextToken:n.nextToken,timeout:3e4},{success:function(r,o){try{n.agent=n.agent||{},n.agent.snapshot=r.snapshot,n.agent.snapshot.localTimestamp=t.now(),n.agent.snapshot.skew=n.agent.snapshot.snapshotTimestamp-n.agent.snapshot.localTimestamp,n.nextToken=r.nextToken,o&&o.hasOwnProperty("contentLength")&&(n.agent.snapshot.contentLength=o.contentLength),t.getLog().trace("GET_AGENT_SNAPSHOT succeeded.").withObject(r).sendInternalLogToServer(),n.updateAgent()}catch(e){t.getLog().error("Long poll failed to update agent.").withObject(r).withException(e).sendInternalLogToServer()}finally{e.setTimeout(t.hitch(n,n.pollForAgent),100)}},failure:function(r,o){try{t.getLog().error("Failed to get agent data.").sendInternalLogToServer().withObject({err:r,data:o})}finally{e.setTimeout(t.hitch(n,n.pollForAgent),5e3)}},authFailure:function(){r()},accessDenied:t.hitch(n,n.handleAccessDenied)})},s.prototype.pollForAgentConfiguration=function(n){var r=this,o=n||{},i=t.hitch(r,r.handlePollingAuthFail);this.client.call(t.ClientMethods.GET_AGENT_CONFIGURATION,{},{success:function(n){var i=n.configuration;r.pollForAgentPermissions(i),r.pollForAgentStates(i),r.pollForDialableCountryCodes(i),r.pollForRoutingProfileQueues(i),o.repeatForever&&e.setTimeout(t.hitch(r,r.pollForAgentConfiguration,o),3e4)},failure:function(n,i){try{t.getLog().error("Failed to fetch agent configuration data.").sendInternalLogToServer().withObject({err:n,data:i})}finally{o.repeatForever&&e.setTimeout(t.hitch(r,r.pollForAgentConfiguration),3e4,o)}},authFailure:function(){i()},accessDenied:t.hitch(r,r.handleAccessDenied)})},s.prototype.pollForAgentStates=function(e,n){var r=this,o=n||{};o.maxResults=o.maxResults||t.DEFAULT_BATCH_SIZE,this.client.call(t.ClientMethods.GET_AGENT_STATES,{nextToken:o.nextToken||null,maxResults:o.maxResults},{success:function(t){t.nextToken?r.pollForAgentStates(e,{states:(o.states||[]).concat(t.states),nextToken:t.nextToken,maxResults:o.maxResults}):(e.agentStates=(o.states||[]).concat(t.states),r.updateAgentConfiguration(e))},failure:function(e,n){t.getLog().error("Failed to fetch agent states list.").sendInternalLogToServer().withObject({err:e,data:n})},authFailure:t.hitch(r,r.handlePollingAuthFail),accessDenied:t.hitch(r,r.handleAccessDenied)})},s.prototype.pollForAgentPermissions=function(e,n){var r=this,o=n||{};o.maxResults=o.maxResults||t.DEFAULT_BATCH_SIZE,this.client.call(t.ClientMethods.GET_AGENT_PERMISSIONS,{nextToken:o.nextToken||null,maxResults:o.maxResults},{success:function(t){t.nextToken?r.pollForAgentPermissions(e,{permissions:(o.permissions||[]).concat(t.permissions),nextToken:t.nextToken,maxResults:o.maxResults}):(e.permissions=(o.permissions||[]).concat(t.permissions),r.updateAgentConfiguration(e))},failure:function(e,n){t.getLog().error("Failed to fetch agent permissions list.").sendInternalLogToServer().withObject({err:e,data:n})},authFailure:t.hitch(r,r.handlePollingAuthFail),accessDenied:t.hitch(r,r.handleAccessDenied)})},s.prototype.pollForDialableCountryCodes=function(e,n){var r=this,o=n||{};o.maxResults=o.maxResults||t.DEFAULT_BATCH_SIZE,this.client.call(t.ClientMethods.GET_DIALABLE_COUNTRY_CODES,{nextToken:o.nextToken||null,maxResults:o.maxResults},{success:function(t){t.nextToken?r.pollForDialableCountryCodes(e,{countryCodes:(o.countryCodes||[]).concat(t.countryCodes),nextToken:t.nextToken,maxResults:o.maxResults}):(e.dialableCountries=(o.countryCodes||[]).concat(t.countryCodes),r.updateAgentConfiguration(e))},failure:function(e,n){t.getLog().error("Failed to fetch dialable country codes list.").sendInternalLogToServer().withObject({err:e,data:n})},authFailure:t.hitch(r,r.handlePollingAuthFail),accessDenied:t.hitch(r,r.handleAccessDenied)})},s.prototype.pollForRoutingProfileQueues=function(e,n){var r=this,o=n||{};o.maxResults=o.maxResults||t.DEFAULT_BATCH_SIZE,this.client.call(t.ClientMethods.GET_ROUTING_PROFILE_QUEUES,{routingProfileARN:e.routingProfile.routingProfileARN,nextToken:o.nextToken||null,maxResults:o.maxResults},{success:function(t){t.nextToken?r.pollForRoutingProfileQueues(e,{countryCodes:(o.queues||[]).concat(t.queues),nextToken:t.nextToken,maxResults:o.maxResults}):(e.routingProfile.queues=(o.queues||[]).concat(t.queues),r.updateAgentConfiguration(e))},failure:function(e,n){t.getLog().error("Failed to fetch routing profile queues list.").sendInternalLogToServer().withObject({err:e,data:n})},authFailure:t.hitch(r,r.handlePollingAuthFail),accessDenied:t.hitch(r,r.handleAccessDenied)})},s.prototype.handleAPIRequest=function(e,n){var r=this;this.client.call(n.method,n.params,{success:function(r){var o=t.EventFactory.createResponse(t.EventType.API_RESPONSE,n,r);e.sendDownstream(o.event,o)},failure:function(o,i){var a=t.EventFactory.createResponse(t.EventType.API_RESPONSE,n,i,JSON.stringify(o));e.sendDownstream(a.event,a),t.getLog().error("'%s' API request failed",n.method).withObject({request:r.filterAuthToken(n),response:a}).withException(o).sendInternalLogToServer()},authFailure:t.hitch(r,r.handleAuthFail,{authorize:!0})})},s.prototype.handleMasterRequest=function(e,n,r){var o=this.conduit,i=null;switch(r.method){case t.MasterMethods.BECOME_MASTER:var a=this.masterCoord.getMaster(r.params.topic),s=Boolean(a)&&a!==n;this.masterCoord.setMaster(r.params.topic,n),i=t.EventFactory.createResponse(t.EventType.MASTER_RESPONSE,r,{masterId:n,takeOver:s,topic:r.params.topic}),s&&o.sendDownstream(i.event,i);break;case t.MasterMethods.CHECK_MASTER:(a=this.masterCoord.getMaster(r.params.topic))||r.params.shouldNotBecomeMasterIfNone||(this.masterCoord.setMaster(r.params.topic,n),a=n),i=t.EventFactory.createResponse(t.EventType.MASTER_RESPONSE,r,{masterId:a,isMaster:n===a,topic:r.params.topic});break;default:throw new Error("Unknown master method: "+r.method)}e.sendDownstream(i.event,i)},s.prototype.handleTabIdEvent=function(e,n){var r=this;try{var o=n.tabId,i=r.streamMapByTabId[o],a=e.getId(),s=Object.keys(r.streamMapByTabId).filter((function(e){return r.streamMapByTabId[e].length>0})).length;if(i&&i.length>0){if(!i.includes(a)){r.streamMapByTabId[o].push(a);var c={length:Object.keys(r.portConduitMap).length,tabId:o,streamsTabsAcrossBrowser:s};c[o]={length:i.length},r.conduit.sendDownstream(t.EventType.UPDATE_CONNECTED_CCPS,c)}}else{r.streamMapByTabId[o]=[e.getId()];var u={length:Object.keys(r.portConduitMap).length,tabId:o,streamsTabsAcrossBrowser:s+1};u[o]={length:r.streamMapByTabId[o].length},r.conduit.sendDownstream(t.EventType.UPDATE_CONNECTED_CCPS,u)}}catch(e){t.getLog().error("[Tab Ids] Issue updating connected CCPs within the same tab").withException(e).sendInternalLogToServer()}},s.prototype.handleCloseEvent=function(e){var n=this;n.multiplexer.removeStream(e),delete n.portConduitMap[e.getId()],n.masterCoord.removeMaster(e.getId());var r={length:Object.keys(n.portConduitMap).length},o=Object.keys(n.streamMapByTabId);try{var i=o.find((function(t){return n.streamMapByTabId[t].includes(e.getId())}));if(i){var a=n.streamMapByTabId[i].findIndex((function(t){return e.getId()===t}));n.streamMapByTabId[i].splice(a,1);var s=n.streamMapByTabId[i]?n.streamMapByTabId[i].length:0;r[i]={length:s},r.tabId=i}var c=o.filter((function(e){return n.streamMapByTabId[e].length>0})).length;r.streamsTabsAcrossBrowser=c}catch(e){t.getLog().error("[Tab Ids] Issue updating tabId-specific stream data").withException(e).sendInternalLogToServer()}n.conduit.sendDownstream(t.EventType.UPDATE_CONNECTED_CCPS,r)},s.prototype.updateAgentConfiguration=function(e){e.permissions&&e.dialableCountries&&e.agentStates&&e.routingProfile.queues?(this.agent=this.agent||{},this.agent.configuration=e,this.updateAgent()):t.getLog().trace("Waiting to update agent configuration until all config data has been fetched.").sendInternalLogToServer()},s.prototype.updateAgent=function(){this.agent?this.agent.snapshot?this.agent.configuration?(this.agent.snapshot.status=this.agent.state,this.agent.snapshot.contacts&&this.agent.snapshot.contacts.length>1&&this.agent.snapshot.contacts.sort((function(e,t){return e.state.timestamp.getTime()-t.state.timestamp.getTime()})),this.agent.snapshot.contacts.forEach((function(e){e.status=e.state,e.connections.forEach((function(e){e.address=e.endpoint}))})),this.agent.configuration.routingProfile.defaultOutboundQueue.queueId=this.agent.configuration.routingProfile.defaultOutboundQueue.queueARN,this.agent.configuration.routingProfile.queues.forEach((function(e){e.queueId=e.queueARN})),this.agent.snapshot.contacts.forEach((function(e){void 0!==e.queue&&(e.queue.queueId=e.queue.queueARN)})),this.agent.configuration.routingProfile.routingProfileId=this.agent.configuration.routingProfile.routingProfileARN,this.suppress&&(this.agent.snapshot.contacts=this.agent.snapshot.contacts.filter((function(e){return e.state.type==t.ContactStateType.CONNECTED||e.state.type==t.ContactStateType.ENDED})),this.forceOffline&&this.conduit.sendDownstream(t.DisasterRecoveryEvents.FORCE_OFFLINE)),this.conduit.sendDownstream(t.AgentEvents.UPDATE,this.agent)):t.getLog().trace("Waiting to update agent until the agent configuration is available.").sendInternalLogToServer():t.getLog().trace("Waiting to update agent until the agent snapshot is available.").sendInternalLogToServer():t.getLog().trace("Waiting to update agent until the agent has been fully constructed.").sendInternalLogToServer()},s.prototype.getWebSocketUrl=function(){var e=this,n=t.core.getClient(),r=t.hitch(e,e.handleAuthFail),o=t.hitch(e,e.handleAccessDenied);return new Promise((function(e,i){n.call(t.ClientMethods.CREATE_TRANSPORT,{transportType:t.TRANSPORT_TYPES.WEB_SOCKET},{success:function(n){t.getLog().info("getWebSocketUrl succeeded").sendInternalLogToServer(),e(n)},failure:function(e,n){t.getLog().error("getWebSocketUrl failed").sendInternalLogToServer().withObject({err:e,data:n}),i({reason:"getWebSocketUrl failed",_debug:e})},authFailure:function(){t.getLog().error("getWebSocketUrl Auth Failure").sendInternalLogToServer(),i(Error("Authentication failed while getting getWebSocketUrl")),r()},accessDenied:function(){t.getLog().error("getWebSocketUrl Access Denied Failure").sendInternalLogToServer(),i(Error("Access Denied Failure while getting getWebSocketUrl")),o()}})}))},s.prototype.handleSendLogsRequest=function(){var e=this,n=[],r=e.logsBuffer.slice();e.logsBuffer=[],r.forEach((function(e){n.push({timestamp:e.time,component:e.component,message:e.text})})),this.client.call(t.ClientMethods.SEND_CLIENT_LOGS,{logEvents:n},{success:function(e){t.getLog().info("SendLogs request succeeded.").sendInternalLogToServer()},failure:function(e,n){t.getLog().error("SendLogs request failed.").withObject(n).withException(e).sendInternalLogToServer()},authFailure:t.hitch(e,e.handleAuthFail)})},s.prototype.handleAuthFail=function(e){e?this.conduit.sendDownstream(t.EventType.AUTH_FAIL,e):this.conduit.sendDownstream(t.EventType.AUTH_FAIL)},s.prototype.handlePollingAuthFail=function(){this.conduit.sendDownstream(t.EventType.CTI_AUTHORIZE_RETRIES_EXHAUSTED)},s.prototype.handleAccessDenied=function(){this.conduit.sendDownstream(t.EventType.ACCESS_DENIED)},s.prototype.checkAuthToken=function(){var e=this,n=new Date(e.initData.authTokenExpiration),r=(new Date).getTime();n.getTime()<r+18e5&&(t.getLog().info("Auth token expires at "+n+" Start refreshing token with retry.").sendInternalLogToServer(),t.backoff(t.hitch(e,e.authorize),1e4,4))},s.prototype.authorize=function(e){var n=this;t.core.authorize(this.initData.authorizeEndpoint).then((function(r){var o=new Date(r.expiration);t.getLog().info("Authorization succeeded and the token expires at %s",o).sendInternalLogToServer(),n.initData.authToken=r.accessToken,n.initData.authTokenExpiration=o,t.core.initClient(n.initData),t.core.initAgentAppClient(n.initData),e.success()})).catch((function(r){t.getLog().error("Authorization failed with code %s",r.status).sendInternalLogToServer(),401===r.status?n.handleAuthFail():e.failure()}))},s.prototype.filterAuthToken=function(e){var t={};for(var n in e)if("params"===n){var r={};for(var o in e.params)"authentication"!==o&&(r[o]=e.params[o]);t.params=r}else t[n]=e[n];return t},t.worker.main=function(){t.worker.clientEngine=new s}}()}},t={};function n(r){var o=t[r];if(void 0!==o)return o.exports;var i=t[r]={exports:{}};return e[r].call(i.exports,i,i.exports,n),i.exports}n.amdO={},n.d=(e,t)=>{for(var r in t)n.o(t,r)&&!n.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},n.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),n.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),n.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},n(167),n(254),n(344),n(144),n(60),n(682),n(431),n(555),n(830),n(414),n(610),n(95),n(399),n(906),n(806),n(354),n(142),n(884),n(390),n(269),n(825),n(961),n(949)})();"),d=function(l){this.id=l.region,l.region=this._normalizeRegionString(l.region),this.height=l.height,this.style=l.iframe_style,this.ccp=this._createFramedCcp(l)};d.prototype._createFramedCcp=function(l){var Z=Z||"microphone; autoplay; clipboard-write",b=this.style||"margin: 0; border: 0; padding: 0px; width: 0px; height: 0px",d=document.createElement("iframe");return d.srcdoc=this.getContent(l),d.allow=Z,d.id=this.id,d.style=b,d.scrolling="no",d},d.prototype.getContent=function(l){return["","","","","