@paydock/client-sdk 1.145.0-beta → 1.148.0-beta

package/bundles/index.cjs

@@ -1865,7 +1865,7 @@ SDK.headerKeys = Object.freeze({
   version: 'x-sdk-version',
   type: 'x-sdk-type'
 });
-SDK._version = 'v1.145.0-beta';
+SDK._version = 'v1.148.0-beta';
 
 var ACCESS_HEADER_NAME = {
   accessToken: 'x-access-token',
@@ -4721,6 +4721,15 @@ var ApiBase = /*#__PURE__*/function () {
       this.env.setEnv(env, alias);
       return this;
     }
+    /**
+     * Origin (`scheme://host[:port]`) of the API this client talks to, for the current env/alias.
+     * Used to validate the `origin` of postMessages the API itself sends to the page.
+     */
+  }, {
+    key: "getApiOrigin",
+    value: function getApiOrigin() {
+      return ApiBase.toOrigin(this.env.getConf().url);
+    }
   }, {
     key: "requestObservable",
     value: function requestObservable(method, url, requestBody) {
@@ -4933,6 +4942,18 @@ var ApiBase = /*#__PURE__*/function () {
         environment: this.env.getEnv()
       };
     }
+  }], [{
+    key: "toOrigin",
+    value: function toOrigin(url) {
+      try {
+        return new URL(url).origin;
+      } catch (_a) {
+        // Not a parsable URL: the returned string is not an origin and will never match a
+        // MessageEvent.origin — surface the misconfiguration instead of failing silently.
+        console.warn("[paydock/client-sdk] cannot derive an origin from configured URL \"".concat(url, "\""));
+        return url.replace(/\/+$/, '');
+      }
+    }
   }]);
 }();
 
@@ -5010,6 +5031,7 @@ var ApiChargeInternal = /*#__PURE__*/function () {
     value: function walletCallback(payload) {
       return this.api.getClientPromise('POST', WALLET_CALLBACK_LINK).send(payload);
     }
+    /** Two-step mode: runs the deferred Standalone 3DS authentication (AReq). Charge-token auth, like `standalone3dsHandle`. */
   }, {
     key: "standalone3dsProcess",
     value: function standalone3dsProcess(payload) {
@@ -5153,6 +5175,10 @@ var IFrame = /*#__PURE__*/function () {
     _classCallCheck(this, IFrame);
     this.container = container;
   }
+  /**
+   * @param options.onLoad Called on every `load` of the iframe (initial document and each
+   *        subsequent navigation). Attached before `src` is set so a fast load is never missed.
+   */
   return _createClass(IFrame, [{
     key: "load",
     value: function load(link) {
@@ -5161,6 +5187,9 @@ var IFrame = /*#__PURE__*/function () {
       if (!this.container.isExist() || this.isExist()) return;
       var iFrame = document.createElement('iframe');
       if (options.title) iFrame.title = options.title;
+      if (options.onLoad) {
+        iFrame.addEventListener('load', options.onLoad);
+      }
       if (iframeClass) iFrame.classList.add(iframeClass);
       // Set additional attributes before src and DOM insertion so that
       // Permissions-Policy (e.g. allow="payment") is in place when the
@@ -5301,14 +5330,14 @@ var IFrameEvent = /*#__PURE__*/function () {
         data = JSON.parse(event.data);
       } catch (error) {}
       if (!data) return;
-      _this.emit(data);
+      _this.emit(data, event.origin);
     });
   }
   return _createClass(IFrameEvent, [{
     key: "emit",
-    value: function emit(data) {
+    value: function emit(data, origin) {
       for (var key in this.listeners) {
-        if (this.listeners[key].event === data.event && data.widget_id === this.listeners[key].widget_id) this.listeners[key].listener.apply(this, [data]);
+        if (this.listeners[key].event === data.event && data.widget_id === this.listeners[key].widget_id) this.listeners[key].listener.apply(this, [data, origin]);
       }
     }
   }, {
@@ -5368,6 +5397,51 @@ var IFRAME_STATUS;
   IFRAME_STATUS["TIMEOUT"] = "AuthTimedOut";
   IFRAME_STATUS["INVALID"] = "invalid_event";
 })(IFRAME_STATUS || (IFRAME_STATUS = {}));
+/**
+ * Maps a `/process` rejection onto the error object the one-step callback delivers for the same outcome
+ * (`{ error_code, error_description, gateway_specific_description, process_error_code }`), so `error`
+ * carries the same payload in both flows. Absent fields are left out.
+ */
+function toOutcomeError(err) {
+  var _a, _b;
+  if (err instanceof Error) {
+    // no API envelope to map (the body was not the API's JSON): report it as unreachable, so the
+    // merchant can tell this retryable case apart from a final API answer by `error_code` alone
+    return {
+      error_code: ERROR_CAUSE.SERVICE_UNREACHABLE,
+      error_description: 'Network request failed: the service did not answer with a valid response.'
+    };
+  }
+  var apiError = err !== null && err !== void 0 ? err : {};
+  var gateway = (_b = (_a = apiError.details) === null || _a === void 0 ? void 0 : _a.messages) === null || _b === void 0 ? void 0 : _b[0];
+  var fields = {
+    error_code: apiError.code,
+    error_description: apiError.message,
+    gateway_specific_description: gateway === null || gateway === void 0 ? void 0 : gateway.gateway_specific_description,
+    process_error_code: gateway === null || gateway === void 0 ? void 0 : gateway.gateway_specific_code
+  };
+  var outcomeError = {};
+  for (var _i = 0, _Object$keys = Object.keys(fields); _i < _Object$keys.length; _i++) {
+    var key = _Object$keys[_i];
+    if (fields[key]) {
+      outcomeError[key] = fields[key];
+    }
+  }
+  return outcomeError;
+}
+/**
+ * `true` when `/process` produced no API answer: the request never got a response (network, timeout, abort)
+ * or the response body was not the API's JSON (e.g. an HTML page from a proxy in between).
+ */
+function isTransportFailure(err) {
+  if (err instanceof Error) {
+    return true;
+  }
+  var code = err === null || err === void 0 ? void 0 : err.code;
+  return code === ERROR_CAUSE.SERVICE_UNREACHABLE || code === ERROR_CAUSE.ABORTED;
+}
+/** Callback `process_status` of a two-step charge: fingerprint done, authentication not started. */
+var PROCESS_STATUS_DEFERRED = 'deferred';
 /**
  * Event name constants emitted during the Standalone 3DS (GPayments) flow.
  * Used internally by `GPaymentsService` and re-exported publicly as `CANVAS_3DS_EVENT`.
@@ -5381,6 +5455,25 @@ var GPAYMENTS_EVENT = {
   DECOUPLED: 'chargeAuthDecoupled',
   /** Challenge required — issuer demands user interaction. Payload: `Canvas3dsAuthPayload`. */
   CHALLENGE: 'chargeAuthChallenge',
+  /**
+   * Two-step mode only: fingerprint done, SDK waiting for `Canvas3ds.authenticate()`. Emitted once, before any
+   * outcome event (`INFO` may precede it); never for a one-step charge. Payload: `Canvas3dsReadyPayload`.
+   */
+  READY: 'chargeAuthReady',
+  /**
+   * The challenge iframe fired its FIRST `load` after `chargeAuthChallenge` (the ACS page has painted),
+   * or the `CHALLENGE_LOADED_FALLBACK_MS` safety fallback elapsed without one. Emitted exactly once per
+   * challenge; never emitted for a decoupled challenge (no challenge iframe). Payload: `Canvas3dsChallengeLoadedPayload`.
+   */
+  CHALLENGE_LOADED: 'chargeAuthChallengeLoaded',
+  /**
+   * The issuer delivered the final authentication result to the 3DS Server (the shopper finished the
+   * challenge, or approved a decoupled authentication) and the SDK is now obtaining the outcome. Emitted at
+   * most once per authentication, always before the terminal event. Detected through the `secondary_url`
+   * result monitor (`source: 'poll'`) or, when the callback message arrives first, right before the outcome
+   * it carries (`source: 'callback'`). Payload: `Canvas3dsChallengeCompletedPayload`.
+   */
+  CHALLENGE_COMPLETED: 'chargeAuthChallengeCompleted',
   /** Informational signal emitted by the GPayments flow. Internal — not part of the public typed surface. */
   INFO: 'chargeAuthInfo',
   /** Error during the flow (network, parsing, etc.). Payload: `Canvas3dsErrorPayload`. */
@@ -5392,13 +5485,64 @@ var GPAYMENTS_EVENT = {
  * backwards-compatible internal usage.
  */
 var CANVAS_3DS_EVENT = GPAYMENTS_EVENT;
+/**
+ * Upper bound on how long `chargeAuthChallengeLoaded` waits for the challenge iframe's first `load`.
+ * When it elapses the event is emitted with `reason: 'timeout'` so a merchant loader is never held
+ * forever; the real `load` arriving afterwards is the paint and is simply ignored.
+ */
+var CHALLENGE_LOADED_FALLBACK_MS = 2500;
+/**
+ * Interval of the `secondary_url` (GPayments `resultMonUrl`) poll while an ACS challenge is on screen.
+ * The monitor flips to `AuthResultReady` when the issuer's RReq reaches the 3DS Server — before the ACS has
+ * even returned its final page to the browser — so this poll is what makes `chargeAuthChallengeCompleted`
+ * land before the shopper sees any post-submit page. GPayments recommends 2 s and leaves the interval to the
+ * requestor; 1 s matches the cadence of GPayments' own monitoring frame.
+ */
+var CHALLENGE_RESULT_POLL_INTERVAL_MS = 1000;
+/**
+ * Interval of the `secondary_url` poll for a decoupled challenge (shopper approves out-of-band, possibly
+ * minutes later; nothing to cover on screen) — the GPayments-recommended 2 s.
+ */
+var DECOUPLED_RESULT_POLL_INTERVAL_MS = 2000;
+/** The result-monitor request failed at transport level (network, abort, timeout) — retried, not fatal. */
+var ResultMonitorTransportError = /*#__PURE__*/function (_Error) {
+  function ResultMonitorTransportError() {
+    var _this;
+    _classCallCheck(this, ResultMonitorTransportError);
+    _this = _callSuper(this, ResultMonitorTransportError, ['Standalone 3DS result monitor request failed']);
+    _this.name = 'ResultMonitorTransportError';
+    return _this;
+  }
+  _inherits(ResultMonitorTransportError, _Error);
+  return _createClass(ResultMonitorTransportError);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
 var GPaymentsService = /*#__PURE__*/function () {
   function GPaymentsService(container, api, eventEmitter) {
+    var trustedOrigins = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];
     _classCallCheck(this, GPaymentsService);
     this.container = container;
     this.api = api;
     this.eventEmitter = eventEmitter;
+    this.trustedOrigins = trustedOrigins;
     this.resultRead = false;
+    /** `chargeAuthChallengeLoaded` already emitted for the current challenge (by `load` or by the fallback). */
+    this.challengeLoadedEmitted = false;
+    /** `chargeAuthChallengeCompleted` already emitted for the current authentication (poll or callback). */
+    this.challengeCompletedEmitted = false;
+    /** Set once a terminal event was emitted: no lifecycle event may follow (reset when a new challenge starts). */
+    this.challengeLifecycleClosed = false;
+    this.challengeLoadedTimer = null;
+    this.resultPollTimer = null;
+    /** One-shot guard for the `chargeAuth` leg — the callback message may be delivered more than once. */
+    this.authHandled = false;
+    /** Two-step mode: `charge_3ds_id` of the deferred callback message; `null` until it arrives (always for one-step). */
+    this.deferredCharge3dsId = null;
+    /** `authenticate()` latch; consumed when the deferred message arrives, reset only after a `/process` transport failure. */
+    this.authenticateRequested = false;
+    /** One `/process` call per widget instance (a transport failure allows one more `authenticate()`). */
+    this.authenticationStarted = false;
+    /** The single `/process` retry after a transport failure has been granted; the next failure is final. */
+    this.authenticationRetryUsed = false;
     this.iFrameEvent = new IFrameEvent(window);
   }
   return _createClass(GPaymentsService, [{
@@ -5418,6 +5562,7 @@ var GPaymentsService = /*#__PURE__*/function () {
     key: "initializeIFrames",
     value: function initializeIFrames(initializationUrl, secondaryUrl, title) {
       var hideAuthorization = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+      var onLoad = arguments.length > 4 ? arguments[4] : undefined;
       var container = this.container.getElement();
       if (!container) {
         return;
@@ -5428,7 +5573,8 @@ var GPaymentsService = /*#__PURE__*/function () {
       this.browserAndChallengeContainer = new Container('#paydock_authorization_iframe');
       this.iFrameAuthorization = new IFrame(this.browserAndChallengeContainer);
       this.iFrameAuthorization.load(initializationUrl, {
-        title: title
+        title: title,
+        onLoad: onLoad
       });
       if (secondaryUrl) {
         var divSecondaryURL = document.createElement('div');
@@ -5462,25 +5608,250 @@ var GPaymentsService = /*#__PURE__*/function () {
   }, {
     key: "setupIFrameEvents",
     value: function setupIFrameEvents(widgetId) {
-      var _this = this;
-      this.iFrameEvent.on(EVENT$4.CHARGE_AUTH, widgetId, function (data) {
+      var _this2 = this;
+      this.iFrameEvent.on(EVENT$4.CHARGE_AUTH, widgetId, function (data, origin) {
         if (data.status === IFRAME_STATUS.SKIPPED || data.status === IFRAME_STATUS.FINISHED) {
+          // this channel is spoofable — any frame that knows the charge_3ds_id can post to it.
+          // A message from an unknown sender must never terminate a live authentication: ignore it.
+          if (!_this2.isTrustedOrigin(origin)) {
+            return;
+          }
+          // one-shot: the callback message can be delivered more than once (it is posted to both
+          // `parent` and `top`) — a duplicate must not re-emit events or duplicate challenge iframes
+          if (_this2.authHandled) {
+            return;
+          }
+          _this2.authHandled = true;
           if (data.info) {
-            _this.eventEmitter.emit(GPAYMENTS_EVENT.INFO, {
+            _this2.eventEmitter.emit(GPAYMENTS_EVENT.INFO, {
               info: data.info
             });
           }
-          _this.performAuthentication(data);
+          _this2.removeIframes();
+          if (data.process_status === PROCESS_STATUS_DEFERRED) {
+            // two-step: announce readiness; authenticate now only if `authenticate()` was already called
+            _this2.deferredCharge3dsId = data.charge_3ds_id;
+            _this2.eventEmitter.emit(GPAYMENTS_EVENT.READY, {
+              charge_3ds_id: data.charge_3ds_id
+            });
+            if (_this2.authenticateRequested) {
+              _this2.performAuthentication(data.charge_3ds_id);
+            }
+          } else if (typeof data.process_status === 'string') {
+            // the API already ran the authentication inside the callback: no /process call needed
+            _this2.handleAuthenticationOutcome({
+              status: data.process_status,
+              result: data.result,
+              error: data.error
+            }, data.charge_3ds_id);
+          } else {
+            // The API always runs the authentication inside the callback (PAYRAC-2480). A trusted
+            // message without the outcome means an outdated API — fail, never verify via /process.
+            _this2.finishChallengeLifecycle();
+            _this2.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this2.parseError({
+              message: 'Standalone 3DS authentication outcome missing from the callback message'
+            }, data.charge_3ds_id));
+          }
         } else if (data.status === IFRAME_STATUS.TIMEOUT || data.status === IFRAME_STATUS.INVALID) {
-          _this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, _this.parseHandleResponse({
+          _this2.finishChallengeLifecycle();
+          _this2.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, _this2.parseHandleResponse({
             status: data.status
           }, data.charge_3ds_id));
         }
       });
-      this.iFrameEvent.on(EVENT$4.CHARGE_AUTH_SUCCESS, widgetId, function (data) {
-        _this.processResult(data.charge_3ds_id);
+      this.iFrameEvent.on(EVENT$4.CHARGE_AUTH_SUCCESS, widgetId, function (data, origin) {
+        // the callback iframe reached Paydock with `AuthResultReady`: the issuer has answered. Announce it
+        // before the outcome so merchants always see completed → terminal, whichever transport won.
+        _this2.emitChallengeCompleted(data.charge_3ds_id, 'callback');
+        if (_this2.hasChainedOutcome(data, origin)) {
+          // the API already fetched the challenge result inside the callback: no GET /handle needed
+          _this2.handleResultOutcome({
+            status: data.process_status,
+            result: data.result,
+            error: data.error
+          }, data.charge_3ds_id);
+        } else {
+          _this2.processResult(data.charge_3ds_id);
+        }
       });
     }
+    /**
+     * Two-step mode: run the deferred authentication (`POST /standalone-3ds/process`). Never throws: runs now if
+     * the deferred message already arrived, otherwise as soon as it does; a no-op on one-step charges, repeated
+     * calls or after a terminal outcome. The outcome flows through the usual events.
+     */
+  }, {
+    key: "authenticate",
+    value: function authenticate() {
+      if (this.authenticateRequested) {
+        return;
+      }
+      this.authenticateRequested = true;
+      if (this.deferredCharge3dsId !== null) {
+        this.performAuthentication(this.deferredCharge3dsId);
+      }
+    }
+    /**
+     * Calls `/process` once per instance (reachable from both the deferred message and `authenticate()`). The
+     * response has the callback-outcome shape, so the challenge / decoupled / result legs are shared with
+     * one-step. A rejection surfaces as `error`, with the same error object shape as the one-step callback
+     * (`toOutcomeError`). An API answer (stale session, rejected authentication…) is terminal. The first transport
+     * failure is not: the AReq may have run with its response lost, so the latches are reset and the merchant may
+     * call `authenticate()` once more — `/process` is idempotent and replays the stored outcome. A failure of that
+     * retry, of any kind, is final.
+     */
+  }, {
+    key: "performAuthentication",
+    value: function performAuthentication(charge3dsId) {
+      var _this3 = this;
+      if (this.authenticationStarted) {
+        return;
+      }
+      this.authenticationStarted = true;
+      this.api.charge().standalone3dsProcess({
+        charge_3ds_id: charge3dsId
+      }).then(function (authenticationResult) {
+        return _this3.handleAuthenticationOutcome(authenticationResult, charge3dsId);
+      }, function (err) {
+        if (isTransportFailure(err) && !_this3.authenticationRetryUsed) {
+          _this3.authenticationRetryUsed = true;
+          _this3.authenticateRequested = false;
+          _this3.authenticationStarted = false;
+        } else {
+          _this3.resultRead = true;
+          _this3.finishChallengeLifecycle();
+        }
+        _this3.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this3.parseError(toOutcomeError(err), charge3dsId));
+      });
+    }
+    /**
+     * A message carries a processed outcome only when it has `process_status` AND comes from a trusted
+     * origin. Used by the result leg: an untrusted `process_status` is never acted upon — the SDK falls
+     * back to `GET /handle` (still needed for decoupled challenges / polling). The authentication leg
+     * ignores untrusted senders outright, before this check.
+     */
+  }, {
+    key: "hasChainedOutcome",
+    value: function hasChainedOutcome(data, origin) {
+      return typeof data.process_status === 'string' && this.isTrustedOrigin(origin);
+    }
+  }, {
+    key: "isTrustedOrigin",
+    value: function isTrustedOrigin(origin) {
+      // 'null' is the serialized opaque origin (e.g. a sandboxed iframe) — never trust it, even if a
+      // misconfigured env URL were ever to put the literal string 'null' into the trusted list
+      return typeof origin === 'string' && origin !== 'null' && this.trustedOrigins.includes(origin);
+    }
+  }, {
+    key: "removeIframes",
+    value: function removeIframes() {
+      var _a, _b;
+      this.clearChallengeLoadedTimer();
+      (_a = this.iFrameAuthorization) === null || _a === void 0 ? void 0 : _a.remove();
+      (_b = this.iFrameSecondaryUrl) === null || _b === void 0 ? void 0 : _b.remove();
+    }
+  }, {
+    key: "clearChallengeLoadedTimer",
+    value: function clearChallengeLoadedTimer() {
+      if (this.challengeLoadedTimer !== null) {
+        clearTimeout(this.challengeLoadedTimer);
+        this.challengeLoadedTimer = null;
+      }
+    }
+    /**
+     * Challenge iframe lifecycle (`chargeAuthChallengeLoaded`).
+     *
+     * The challenge iframe is cross-origin, but its `load` event still fires when the ACS page finishes loading:
+     * the first one means the page painted (merchants can drop their loader). A fallback timer
+     * (`armChallengeLoadedFallback`) guarantees `chargeAuthChallengeLoaded` within `CHALLENGE_LOADED_FALLBACK_MS`
+     * even if no `load` ever fires; a late paint after that is simply ignored. Later `load`s are NOT a usable
+     * signal for "the shopper submitted": the post-submit hops are HTTP redirects and self-submitting pages whose
+     * loads abort, and the final callback page posts its message before its own `load` — so the post-submit
+     * moment is `chargeAuthChallengeCompleted`, driven by the `secondary_url` result monitor instead.
+     *
+     * Nothing is emitted once the flow reached a terminal outcome (`finishChallengeLifecycle`), and a
+     * decoupled challenge (no challenge iframe) never emits `chargeAuthChallengeLoaded`.
+     *
+     * Resets the per-challenge state and returns the `load` handler to attach to the challenge iframe.
+     */
+  }, {
+    key: "startChallengeLifecycle",
+    value: function startChallengeLifecycle(charge3dsId) {
+      var _this4 = this;
+      this.clearChallengeLoadedTimer();
+      this.challengeLoadedEmitted = false;
+      this.challengeCompletedEmitted = false;
+      this.challengeLifecycleClosed = false;
+      return function () {
+        var _a;
+        if (_this4.challengeLifecycleClosed || _this4.challengeLoadedEmitted || !((_a = _this4.iFrameAuthorization) === null || _a === void 0 ? void 0 : _a.isExist())) {
+          return;
+        }
+        _this4.clearChallengeLoadedTimer();
+        _this4.emitChallengeLoaded(charge3dsId, 'load');
+      };
+    }
+    /**
+     * Arms the `chargeAuthChallengeLoaded` fallback — only when a challenge iframe actually exists (the
+     * container may be gone, or `IFrame.load` may have no-op'd on an already-present iframe).
+     */
+  }, {
+    key: "armChallengeLoadedFallback",
+    value: function armChallengeLoadedFallback(charge3dsId) {
+      var _this5 = this;
+      var _a;
+      if (!((_a = this.iFrameAuthorization) === null || _a === void 0 ? void 0 : _a.isExist())) {
+        return;
+      }
+      this.challengeLoadedTimer = setTimeout(function () {
+        _this5.challengeLoadedTimer = null;
+        if (_this5.challengeLifecycleClosed || _this5.challengeLoadedEmitted) {
+          return;
+        }
+        _this5.emitChallengeLoaded(charge3dsId, 'timeout');
+      }, CHALLENGE_LOADED_FALLBACK_MS);
+    }
+  }, {
+    key: "emitChallengeLoaded",
+    value: function emitChallengeLoaded(charge3dsId, reason) {
+      this.challengeLoadedEmitted = true;
+      this.eventEmitter.emit(GPAYMENTS_EVENT.CHALLENGE_LOADED, {
+        charge_3ds_id: charge3dsId,
+        reason: reason
+      });
+    }
+    /**
+     * `chargeAuthChallengeCompleted` — once per authentication, never after a terminal event. Idempotent so the
+     * poll and the callback message can both call it: the first transport to notice the issuer's result wins.
+     */
+  }, {
+    key: "emitChallengeCompleted",
+    value: function emitChallengeCompleted(charge3dsId, source) {
+      if (this.challengeLifecycleClosed || this.challengeCompletedEmitted) {
+        return;
+      }
+      this.challengeCompletedEmitted = true;
+      this.eventEmitter.emit(GPAYMENTS_EVENT.CHALLENGE_COMPLETED, {
+        charge_3ds_id: charge3dsId,
+        source: source
+      });
+    }
+    /** Call before emitting any terminal event: no lifecycle event may follow it, and the result poll stops. */
+  }, {
+    key: "finishChallengeLifecycle",
+    value: function finishChallengeLifecycle() {
+      this.clearChallengeLoadedTimer();
+      this.stopResultPolling();
+      this.challengeLifecycleClosed = true;
+    }
+  }, {
+    key: "stopResultPolling",
+    value: function stopResultPolling() {
+      if (this.resultPollTimer !== null) {
+        clearTimeout(this.resultPollTimer);
+        this.resultPollTimer = null;
+      }
+    }
   }, {
     key: "parseResultData",
     value: function parseResultData(_ref2, charge3dsId) {
@@ -5514,24 +5885,49 @@ var GPaymentsService = /*#__PURE__*/function () {
   }, {
     key: "processResult",
     value: function processResult(charge3dsId) {
-      var _this2 = this;
+      var _this6 = this;
       if (this.resultRead) {
         return;
       }
       this.resultRead = true;
+      this.finishChallengeLifecycle();
       this.api.charge().standalone3dsHandle().then(function (result) {
         var _a;
-        _this2.iFrameAuthorization.remove();
-        (_a = _this2.iFrameSecondaryUrl) === null || _a === void 0 ? void 0 : _a.remove();
+        _this6.iFrameAuthorization.remove();
+        (_a = _this6.iFrameSecondaryUrl) === null || _a === void 0 ? void 0 : _a.remove();
         if (result.status === PROCESS_STANDALONE_3DS_STATUS.SUCCESS) {
-          _this2.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_SUCCESS, _this2.parseResultData(result, charge3dsId));
+          _this6.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_SUCCESS, _this6.parseResultData(result, charge3dsId));
         } else {
-          _this2.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, _this2.parseResultData(result, charge3dsId));
+          _this6.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, _this6.parseResultData(result, charge3dsId));
         }
       }, function (err) {
-        _this2.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this2.parseError(err, charge3dsId));
+        _this6.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this6.parseError(err, charge3dsId));
       });
     }
+    /** Final (post-challenge) outcome delivered by the API through the callback message. */
+  }, {
+    key: "handleResultOutcome",
+    value: function handleResultOutcome(_ref4, charge3dsId) {
+      var status = _ref4.status,
+        error = _ref4.error;
+      if (this.resultRead) {
+        return;
+      }
+      this.resultRead = true;
+      this.finishChallengeLifecycle();
+      this.removeIframes();
+      if (status === PROCESS_STANDALONE_3DS_STATUS.SUCCESS) {
+        this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_SUCCESS, this.parseResultData({
+          status: status
+        }, charge3dsId));
+      } else if (status === PROCESS_STANDALONE_3DS_STATUS.ERROR) {
+        this.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, this.parseError(error, charge3dsId));
+      } else {
+        this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, this.parseResultData({
+          status: status
+        }, charge3dsId));
+      }
+    }
   }, {
     key: "externalAPI",
     value: function externalAPI(method, url) {
@@ -5545,60 +5941,106 @@ var GPaymentsService = /*#__PURE__*/function () {
             reject(error);
           }
         };
+        // without these a failed request left the promise pending forever and the poll silently dead
+        var fail = function fail() {
+          return reject(new ResultMonitorTransportError());
+        };
+        request.onerror = fail;
+        request.onabort = fail;
+        request.ontimeout = fail;
         request.send();
       });
     }
+    /**
+     * Polls the GPayments result monitor (`secondary_url`) until `AuthResultReady`. It is the primary source of
+     * `chargeAuthChallengeCompleted` (the monitor flips as soon as the issuer's RReq reaches the 3DS Server) and
+     * the fallback transport for the outcome itself (`GET /handle`) when the callback message never arrives —
+     * the only transport for decoupled challenges. Stops once an outcome was obtained or the lifecycle closed.
+     * Transport failures are retried on the same cadence; an unparsable body or an unknown event is fatal.
+     */
   }, {
     key: "doPolling",
-    value: function doPolling(url, charge3dsId) {
-      var _this3 = this;
+    value: function doPolling(url, charge3dsId, intervalMs) {
+      var _this7 = this;
+      this.stopResultPolling();
+      if (this.resultRead || this.challengeLifecycleClosed) {
+        return;
+      }
+      var schedule = function schedule() {
+        _this7.resultPollTimer = setTimeout(function () {
+          _this7.resultPollTimer = null;
+          _this7.doPolling(url, charge3dsId, intervalMs);
+        }, intervalMs);
+      };
       this.externalAPI('GET', url).then(function (data) {
+        if (_this7.resultRead || _this7.challengeLifecycleClosed) {
+          return;
+        }
         if (!data.event || data.event === 'AuthResultNotReady') {
-          setTimeout(function () {
-            _this3.doPolling(url, charge3dsId);
-          }, 2000);
+          schedule();
         } else if (data.event === 'AuthResultReady') {
-          _this3.processResult(charge3dsId);
+          _this7.emitChallengeCompleted(charge3dsId, 'poll');
+          _this7.processResult(charge3dsId);
         } else {
           throw new Error('Event not supported');
         }
       })["catch"](function (err) {
-        return _this3.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this3.parseError(err, charge3dsId));
+        if (err instanceof ResultMonitorTransportError) {
+          if (!_this7.resultRead && !_this7.challengeLifecycleClosed) {
+            schedule();
+          }
+          return;
+        }
+        _this7.finishChallengeLifecycle();
+        _this7.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this7.parseError(err, charge3dsId));
       });
     }
+    /**
+     * Branches on the authentication outcome — delivered by the API through the callback message
+     * (`process_status` → `status`) or, in two-step mode, returned by `/process` (same shape).
+     */
   }, {
-    key: "performAuthentication",
-    value: function performAuthentication(_ref4) {
-      var _this4 = this;
-      var charge_3ds_id = _ref4.charge_3ds_id;
-      var _a;
-      this.iFrameAuthorization.remove();
-      (_a = this.iFrameSecondaryUrl) === null || _a === void 0 ? void 0 : _a.remove();
-      this.api.charge().standalone3dsProcess({
-        charge_3ds_id: charge_3ds_id
-      }).then(function (authenticationResult) {
-        var _a, _b;
-        if (authenticationResult.status === AUTHENTICATION_STATUS.SUCCESS) {
-          _this4.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_SUCCESS, _this4.parseHandleResponse(authenticationResult, charge_3ds_id));
-        } else if (authenticationResult.status === AUTHENTICATION_STATUS.PENDING) {
-          if ((_a = authenticationResult === null || authenticationResult === void 0 ? void 0 : authenticationResult.result) === null || _a === void 0 ? void 0 : _a.challenge) {
-            _this4.eventEmitter.emit(GPAYMENTS_EVENT.CHALLENGE, _this4.parseHandleResponse(authenticationResult, charge_3ds_id));
-            _this4.initializeIFrames(authenticationResult.result.challenge_url, undefined, 'Authentication Challenge', false);
-            if (authenticationResult.result.secondary_url) {
-              _this4.doPolling(authenticationResult.result.secondary_url, charge_3ds_id);
-            }
-          } else if ((_b = authenticationResult === null || authenticationResult === void 0 ? void 0 : authenticationResult.result) === null || _b === void 0 ? void 0 : _b.decoupled_challenge) {
-            _this4.eventEmitter.emit(GPAYMENTS_EVENT.DECOUPLED, _this4.parseHandleResponse(authenticationResult, charge_3ds_id));
-            if (authenticationResult.result.secondary_url) {
-              _this4.doPolling(authenticationResult.result.secondary_url, charge_3ds_id);
-            }
+    key: "handleAuthenticationOutcome",
+    value: function handleAuthenticationOutcome(authenticationResult, charge_3ds_id) {
+      var _a, _b, _c;
+      if (authenticationResult.status !== AUTHENTICATION_STATUS.PENDING) {
+        // terminal outcome — a later `chargeAuthSuccess` message or poll must not emit a second result
+        this.resultRead = true;
+      }
+      if (authenticationResult.status === AUTHENTICATION_STATUS.SUCCESS) {
+        this.finishChallengeLifecycle();
+        this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_SUCCESS, this.parseHandleResponse(authenticationResult, charge_3ds_id));
+      } else if (authenticationResult.status === AUTHENTICATION_STATUS.PENDING) {
+        if ((_a = authenticationResult === null || authenticationResult === void 0 ? void 0 : authenticationResult.result) === null || _a === void 0 ? void 0 : _a.challenge) {
+          this.eventEmitter.emit(GPAYMENTS_EVENT.CHALLENGE, this.parseHandleResponse(authenticationResult, charge_3ds_id));
+          var onChallengeLoad = this.startChallengeLifecycle(charge_3ds_id);
+          this.initializeIFrames(authenticationResult.result.challenge_url, undefined, 'Authentication Challenge', false, onChallengeLoad);
+          this.armChallengeLoadedFallback(charge_3ds_id);
+          if (authenticationResult.result.secondary_url) {
+            this.doPolling(authenticationResult.result.secondary_url, charge_3ds_id, CHALLENGE_RESULT_POLL_INTERVAL_MS);
+          }
+        } else if ((_b = authenticationResult === null || authenticationResult === void 0 ? void 0 : authenticationResult.result) === null || _b === void 0 ? void 0 : _b.decoupled_challenge) {
+          this.challengeCompletedEmitted = false;
+          this.challengeLifecycleClosed = false;
+          this.eventEmitter.emit(GPAYMENTS_EVENT.DECOUPLED, this.parseHandleResponse(authenticationResult, charge_3ds_id));
+          if (authenticationResult.result.secondary_url) {
+            this.doPolling(authenticationResult.result.secondary_url, charge_3ds_id, DECOUPLED_RESULT_POLL_INTERVAL_MS);
           }
         } else {
-          return _this4.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, _this4.parseHandleResponse(authenticationResult, charge_3ds_id));
-        }
-      }, function (err) {
-        _this4.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, _this4.parseError(err, charge_3ds_id));
-      });
+          // pending but nothing to run (no challenge delivered) — fail rather than hang silently
+          // with the iframes already removed and no further message ever coming
+          this.resultRead = true;
+          this.finishChallengeLifecycle();
+          this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, this.parseHandleResponse(authenticationResult, charge_3ds_id));
+        }
+      } else if (authenticationResult.status === AUTHENTICATION_STATUS.ERROR) {
+        // the API rejected the authentication, or could not run it inside the callback
+        this.finishChallengeLifecycle();
+        this.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, this.parseError((_c = authenticationResult.error) !== null && _c !== void 0 ? _c : authenticationResult, charge_3ds_id));
+      } else {
+        this.finishChallengeLifecycle();
+        this.eventEmitter.emit(GPAYMENTS_EVENT.AUTH_ERROR, this.parseHandleResponse(authenticationResult, charge_3ds_id));
+      }
     }
   }]);
 }();
@@ -5625,16 +6067,61 @@ var Standalone3dsService = /*#__PURE__*/function () {
       api.setEnv(this.env, this.alias);
       switch (tokenData.service_type) {
         case STANDALONE_3DS_GATEWAYS.GPAYMENTS:
-          new GPaymentsService(this.container, api, this.eventEmitter).load(tokenData, options.title);
+          this.gpaymentsService = new GPaymentsService(this.container, api, this.eventEmitter, this.getTrustedMessageOrigins(api));
+          this.gpaymentsService.load(tokenData, options.title);
           break;
       }
     }
+    /**
+     * Two-step mode: forwards `Canvas3ds.authenticate()` to the provider flow. Calling it before `load()` is an
+     * integration bug (nothing to authenticate yet): it emits `error` and is not remembered.
+     */
+  }, {
+    key: "authenticate",
+    value: function authenticate(token) {
+      if (!this.gpaymentsService) {
+        this.eventEmitter.emit(GPAYMENTS_EVENT.ERROR, {
+          charge_3ds_id: Standalone3dsService.readCharge3dsId(token),
+          error: {
+            message: 'Canvas3ds.authenticate() called before load()'
+          }
+        });
+        return;
+      }
+      this.gpaymentsService.authenticate();
+    }
+    /** `charge_3ds_id` from the standalone 3DS charge token, `undefined` when it cannot be decoded. */
+  }, {
+    key: "getTrustedMessageOrigins",
+    value:
+    /**
+     * Origins allowed to deliver a processed 3DS outcome to the page via postMessage: the Paydock API
+     * (inline callback page) and the Paydock widget (remote-app landing page), for the current env/alias.
+     */
+    function getTrustedMessageOrigins(api) {
+      var origins = [api.getApiOrigin()];
+      try {
+        var widgetEnv = new Env(WIDGET_URL, this.env);
+        widgetEnv.setEnv(this.env, this.alias);
+        origins.push(ApiBase.toOrigin(widgetEnv.getConf().url));
+      } catch (_a) {
+        // widget origin unknown for this env — the API origin is enough
+      }
+      return origins;
+    }
   }, {
     key: "setEnv",
     value: function setEnv(env, alias) {
       this.env = env;
       this.alias = alias;
     }
+  }], [{
+    key: "readCharge3dsId",
+    value: function readCharge3dsId(token) {
+      var _a;
+      var parsedToken = AccessToken.validateJWT(token);
+      return parsedToken ? (_a = AccessToken.extractData(parsedToken.body)) === null || _a === void 0 ? void 0 : _a.charge_3ds_id : undefined;
+    }
   }]);
 }();
 
@@ -5797,11 +6284,14 @@ var TOKEN_FORMAT$2;
  * @const STANDALONE_3DS_EVENT
  *
  * @type {object}
- * @param {string} CHARGE_AUTH_SUCCESS=chargeAuthSuccess
- * @param {string} CHARGE_AUTH_REJECT=chargeAuthReject
- * @param {string} CHARGE_AUTH_DECOUPLED=chargeAuthDecoupled
- * @param {string} CHARGE_AUTH_CHALLENGE=chargeAuthChallenge
- * @param {string} CHARGE_AUTH_INFO=chargeAuthInfo
+ * @param {string} AUTH_SUCCESS=chargeAuthSuccess
+ * @param {string} AUTH_ERROR=chargeAuthReject
+ * @param {string} DECOUPLED=chargeAuthDecoupled
+ * @param {string} CHALLENGE=chargeAuthChallenge
+ * @param {string} READY=chargeAuthReady - two-step mode only: fingerprint done, waiting for `authenticate()`
+ * @param {string} CHALLENGE_LOADED=chargeAuthChallengeLoaded - challenge iframe painted (first `load`, or 2.5 s fallback); reveal your challenge UI here
+ * @param {string} CHALLENGE_COMPLETED=chargeAuthChallengeCompleted - the shopper finished the challenge (issuer result delivered to the 3DS Server); cover the challenge iframe with your own loader until the terminal event
+ * @param {string} INFO=chargeAuthInfo
  * @param {string} ERROR=error
  */
 /**
@@ -5928,6 +6418,39 @@ var Canvas3ds = /*#__PURE__*/function () {
         });
       }
     }
+    /**
+     * Two-step mode only (`_3ds.authentication_flow: 'two_step'`): runs the authentication the API deferred after the
+     * fingerprint. Call it when the shopper confirms (e.g. presses "Pay"); the outcome arrives through the
+     * usual events (`chargeAuthChallenge`, `chargeAuthSuccess`, `chargeAuthReject`, `error`).
+     *
+     * Never throws. After `chargeAuthReady` the authentication starts at once; before it, the call is
+     * remembered and runs as soon as the fingerprint completes. One-step charges, repeated calls and calls after
+     * a terminal outcome are no-ops. For inbuilt 3DS (`html` / `url`) tokens it is a silent no-op: no event is
+     * emitted at all, so do not wait for `error` there. Calling it before `load()` is an integration error: it emits `error` and
+     * is not remembered. If `/process` could not be reached (`error` with `error_code` `service_unreachable` /
+     * `aborted`), `authenticate()` may be called once more; any other `error`, and any failure of that retry,
+     * is final.
+     * No client-side deadline: a stale 3DS Server session surfaces as `error` / `chargeAuthReject`.
+     *
+     * @example
+     * const widget = new Canvas3ds('#widget', token); // charge created with _3ds.authentication_flow: 'two_step'
+     * widget.on('chargeAuthReady', () => payButton.disabled = false);
+     * widget.on('chargeAuthChallenge', () => showChallengeModal());
+     * widget.on('chargeAuthSuccess', (data) => completePayment(data.charge_3ds_id));
+     * widget.on('chargeAuthReject', () => showDeclined());
+     * widget.on('error', () => showError());
+     * widget.load(); // fingerprint runs while the shopper reviews the order
+     *
+     * payButton.addEventListener('click', () => widget.authenticate());
+     */
+  }, {
+    key: "authenticate",
+    value: function authenticate() {
+      if (this.token.format !== TOKEN_FORMAT$2.STANDALONE_3DS) {
+        return;
+      }
+      this.standalone3dsService.authenticate(this.token.content);
+    }
     /**
      * Using this method you can hide widget after load
      * @param {boolean} [saveSize=false] - using this param you can save iframe's size
@@ -6183,6 +6706,24 @@ var SUPPORTED_CARD_TYPES = {
   EFTPOS_WHITE: 'eftpos_white',
   UNIONPAY: 'unionpay'
 };
+/**
+ * Card schemes the widget is able to resolve from a card number, and therefore the only values
+ * `setAllowedCardSchemes` accepts. This is a separate vocabulary from SUPPORTED_CARD_TYPES, which drives the
+ * card icons: it omits the icon-only variants `visa_white` / `eftpos_white`, and the `laser` / `maestro`
+ * identifiers the widget can never resolve — allowing those would be configuration that can never match.
+ */
+var CARD_SCHEME = {
+  AMEX: 'amex',
+  AUSBC: 'ausbc',
+  DINERS: 'diners',
+  DISCOVER: 'discover',
+  EFTPOS: 'eftpos',
+  JAPCB: 'japcb',
+  MASTERCARD: 'mastercard',
+  SOLO: 'solo',
+  UNIONPAY: 'unionpay',
+  VISA: 'visa'
+};
 var SUPPORTED_CHECKOUT_META_COLLECTION = [].concat([
 // Paypal
 'brand_name', 'cart_border_color', 'reference', 'email', 'hdr_img', 'logo_img', 'pay_flow_color', 'first_name', 'last_name', 'address_line', 'address_line2', 'address_city', 'address_state', 'address_postcode', 'address_country', 'phone', 'hide_shipping_address'], [
@@ -8367,7 +8908,7 @@ var AfterPayWalletService = /*#__PURE__*/function (_WalletService) {
   }]);
 }(WalletService);
 
-/*! @license DOMPurify 3.4.11 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.11/LICENSE */
+/*! @license DOMPurify 3.4.13 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.13/LICENSE */
 
 var purify_cjs;
 var hasRequiredPurify_cjs;
@@ -8687,7 +9228,7 @@ function requirePurify_cjs () {
 	const text = freeze(['#text']);
 
 	const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'command', 'commandfor', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'exportparts', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inert', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'part', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'slot', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns']);
-	const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'mask-type', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
+	const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dominant-baseline', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'mask-type', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-orientation', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
 	const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnalign', 'columnlines', 'columnspacing', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lquote', 'lspace', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
 	const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
 
@@ -8800,7 +9341,7 @@ function requirePurify_cjs () {
 	function createDOMPurify() {
 	  let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
 	  const DOMPurify = root => createDOMPurify(root);
-	  DOMPurify.version = '3.4.11';
+	  DOMPurify.version = '3.4.13';
 	  DOMPurify.removed = [];
 	  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
 	    // Not running in a browser, provide a factory function
@@ -8831,6 +9372,7 @@ function requirePurify_cjs () {
 	  const getAttributes = lookupGetter(ElementPrototype, 'attributes');
 	  const getNodeType = Node && Node.prototype ? lookupGetter(Node.prototype, 'nodeType') : null;
 	  const getNodeName = Node && Node.prototype ? lookupGetter(Node.prototype, 'nodeName') : null;
+	  const getOwnerDocument = Node && Node.prototype ? lookupGetter(Node.prototype, 'ownerDocument') : null;
 	  // As per issue #47, the web-components registry is inherited by a
 	  // new document created via createHTMLDocument. As per the spec
 	  // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
@@ -9482,6 +10024,13 @@ function requirePurify_cjs () {
 	   * @param root the in-place root to empty
 	   */
 	  const _neutralizeRoot = function _neutralizeRoot(root) {
+	    /* Strip every disallowed attribute (on* handlers included) off the whole
+	       subtree BEFORE detaching anything. Detaching first would hand back
+	       handler-bearing originals (e.g. an already-loading `<img onerror>`)
+	       whose queued resource event still fires in page scope after we throw.
+	       Clobber-safe reads; a doomed clobbered node's own attributes are
+	       irrelevant while its non-clobbered descendants are reached and scrubbed. */
+	    _neutralizeSubtree(root);
 	    const childNodes = getChildNodes(root);
 	    if (childNodes) {
 	      const snapshot = [];
@@ -9609,6 +10158,82 @@ function requirePurify_cjs () {
 	      }
 	    }
 	  };
+	  /**
+	   * _neutralizePatchLinkage
+	   *
+	   * IN_PLACE entry pre-pass (declarative-partial-updates / streaming
+	   * hardening, https://github.com/WICG/declarative-partial-updates).
+	   *
+	   * The main walk strips patch linkage (`for`/`patchsrc`) and removes range
+	   * markers (PIs / markup comments) node-by-node, in document order, AS it
+	   * reaches each node. On a live in-place root that leaves a window: from the
+	   * moment the root is connected until the walk arrives at a given node, that
+	   * node's linkage is live. A patch applied on connection/stream can fire as
+	   * a microtask during the walk and inject or teleport an unsanitized DOM
+	   * range into a region the iterator has already passed and will not revisit,
+	   * so the post-return "tree is sanitized" contract is violated. Sweep the
+	   * whole tree once up front and sever every linkage before the walk begins,
+	   * closing that window.
+	   *
+	   * This CANNOT undo a patch that already fired before sanitize ran — that is
+	   * the irreducible "do not IN_PLACE a live-connected attacker tree" caveat —
+	   * but it closes everything from sanitize-start onward. Gated on SAFE_FOR_XML
+	   * to group with the rest of the declarative-partial-updates handling and
+	   * stay overridable, consistent with the codebase.
+	   *
+	   * Clobber-safe traversal (cached childNodes getter); per-node try/catch so a
+	   * clobbered root cannot defeat the sweep of its non-clobbered descendants.
+	   *
+	   * NOTE (pending real-Chrome confirmation, see test/declarative-patch-probe
+	   * .html Q1): this mirrors the existing policy of keeping `for` on
+	   * <label>/<output>. If the shipping feature can drive a patch through a
+	   * surviving `for`-on-label/output + `id` pair, this pre-pass and the
+	   * attribute check at _isBasicCustomElement's caller must additionally drop
+	   * that pair on the IN_PLACE path. Left as-is until the taxonomy is verified.
+	   *
+	   * @param root the in-place root to sweep
+	   */
+	  const _neutralizePatchLinkage = function _neutralizePatchLinkage(root) {
+	    if (!SAFE_FOR_XML) {
+	      return;
+	    }
+	    const stack = [root];
+	    while (stack.length > 0) {
+	      const node = stack.pop();
+	      const nodeType = getNodeType ? getNodeType(node) : node.nodeType;
+	      /* Remove range markers (the target side of a patch linkage): every
+	         processing instruction, and any markup-bearing comment. */
+	      if (nodeType === NODE_TYPE.processingInstruction || nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, node.data)) {
+	        try {
+	          remove(node);
+	        } catch (_) {
+	          /* Best-effort */
+	        }
+	        continue;
+	      }
+	      /* Strip patch-source attributes (the source side) off elements. */
+	      if (nodeType === NODE_TYPE.element) {
+	        const element = node;
+	        const lcTag = transformCaseFunc(getNodeName ? getNodeName(node) : node.nodeName);
+	        try {
+	          if (element.hasAttribute && element.hasAttribute('patchsrc')) {
+	            element.removeAttribute('patchsrc');
+	          }
+	          if (element.hasAttribute && element.hasAttribute('for') && lcTag !== 'label' && lcTag !== 'output') {
+	            element.removeAttribute('for');
+	          }
+	        } catch (_) {
+	          /* Clobbered removeAttribute/hasAttribute on a doomed node — ignore */
+	        }
+	      }
+	      const childNodes = getChildNodes(node);
+	      if (childNodes) {
+	        for (let i = childNodes.length - 1; i >= 0; --i) {
+	          stack.push(childNodes[i]);
+	        }
+	      }
+	    }
+	  };
 	  /**
 	   * _initDocument
 	   *
@@ -9666,7 +10291,17 @@ function requirePurify_cjs () {
 	   * @return The created NodeIterator
 	   */
 	  const _createNodeIterator = function _createNodeIterator(root) {
-	    return createNodeIterator.call(root.ownerDocument || root, root,
+	    /* Read ownerDocument through the cached Node.prototype getter, never the
+	       direct property. HTMLFormElement has [LegacyOverrideBuiltIns], so a
+	       clobbering child (<input name="ownerDocument"> or a form-associated
+	       external input) shadows the prototype getter and makes a direct read
+	       return that <input>. createNodeIterator.call(<input>, ...) then throws
+	       "Illegal invocation", and on the IN_PLACE path that throw lands before
+	       the walk's fail-closed barrier - leaving the caller's live tree, with
+	       any already-armed handler in it, un-neutralized. The cached getter
+	       returns the real Document regardless of the clobber. */
+	    const doc = getOwnerDocument ? getOwnerDocument(root) : root.ownerDocument;
+	    return createNodeIterator.call(doc || root, root,
 	    // eslint-disable-next-line no-bitwise
 	    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
 	  };
@@ -9706,7 +10341,11 @@ function requirePurify_cjs () {
 	  const _scrubTemplateExpressions2 = function _scrubTemplateExpressions(node) {
 	    var _node$querySelectorAl;
 	    node.normalize();
-	    const walker = createNodeIterator.call(node.ownerDocument || node, node,
+	    /* Clobber-safe ownerDocument read, same reasoning as _createNodeIterator:
+	       under SAFE_FOR_TEMPLATES this runs on the live IN_PLACE root, which may
+	       carry a form-named-getter override of ownerDocument. */
+	    const doc = getOwnerDocument ? getOwnerDocument(node) : node.ownerDocument;
+	    const walker = createNodeIterator.call(doc || node, node,
 	    // eslint-disable-next-line no-bitwise
 	    NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_CDATA_SECTION | NodeFilter.SHOW_PROCESSING_INSTRUCTION, null);
 	    let currentNode = walker.nextNode();
@@ -9859,15 +10498,21 @@ function requirePurify_cjs () {
 	  /**
 	   * Handle a node whose tag is forbidden or not allowlisted: keep
 	   * allowed custom elements (false return exits _sanitizeElements
-	   * early - namespace/fallback checks and the afterSanitizeElements
-	   * hook are intentionally skipped for kept custom elements), else
-	   * hoist content per KEEP_CONTENT and remove.
+	   * early - the namespace and fallback-tag removal checks are
+	   * intentionally skipped for kept custom elements), else hoist
+	   * content per KEEP_CONTENT and remove.
+	   *
+	   * A kept custom element is the ONLY case in which this function
+	   * returns false, so the caller uses that return value to run the
+	   * afterSanitizeElements hook on the kept element and keep the
+	   * element-hook lifecycle consistent with normal allowlisted
+	   * elements (GHSA-c2j3-45gr-mqc4).
 	   *
 	   * @param currentNode the disallowed node
 	   * @param tagName the node's transformCaseFunc'd tag name
 	   * @return true if the node was removed, false if kept
 	   */
-	  const _sanitizeDisallowedNode = function _sanitizeDisallowedNode(currentNode, tagName) {
+	  const _sanitizeDisallowedNode = function _sanitizeDisallowedNode(currentNode, tagName, root) {
 	    /* Check if we have a custom element to handle */
 	    if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
 	      if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
@@ -9890,27 +10535,26 @@ function requirePurify_cjs () {
 	      const childNodes = getChildNodes(currentNode);
 	      if (childNodes && parentNode) {
 	        const childCount = childNodes.length;
-	        /* In-place: hoist the *original* children so the iterator visits
-	             and sanitises them through the same allowlist pass as every other
-	             node. The caller built the tree in the live document, so the
-	             originals carry already-queued resource events (`<img onerror>`,
-	             `<video>`/`<audio>` error, lazy/`onload`, …); cloning would leave
-	             those originals detached but still armed, firing in page scope
-	             while the returned tree looked clean. Moving is safe in-place: the
-	             root is pre-validated as an allowed tag and so is never the node
-	             being removed, which keeps `parentNode` inside the iterator root
-	             and the relocated child inside the serialised tree.
-	                      Otherwise (string / DOM-copy paths): clone. The iterator is rooted
-	             at — and the result serialised from — `body`, so a restrictive
-	             ALLOWED_TAGS that removes `body` itself must leave its content in
-	             place, which only cloning does; and those paths parse into an
-	             inert document, so their discarded originals never had a queued
-	             event to neutralise.
+	        /* Hoist by moving each child up one level rather than deep-cloning
+	             it. Moving transfers every descendant exactly once, so a chain of
+	             nested disallowed elements costs O(n) instead of the O(n^2) that
+	             re-cloning the shrinking subtree at each level produced; it also
+	             empties the removed original, so `DOMPurify.removed` no longer
+	             pins whole subtrees. Moving preserves the in-place guarantee too:
+	             an original carrying already-queued resource events (`<img
+	             onerror>`, `<video>`/`<audio>` error, lazy/`onload`, …) is
+	             relocated and sanitised rather than left detached but still armed.
+	                      The sole case that must clone is removing the walk root itself.
+	             The result is serialised from the root's subtree, so a restrictive
+	             ALLOWED_TAGS that strips the root (`body` on the string path) must
+	             leave the content inside it, which only cloning does. In IN_PLACE
+	             the root is pre-validated as an allowed tag and so is never removed
+	             here, so that path always takes the move branch.
 	                      `childNodes` is live; a tail-to-head walk keeps `childNodes[i]`
 	             valid whether we move (drops the trailing entry) or clone (leaves
 	             the list intact). */
 	        for (let i = childCount - 1; i >= 0; --i) {
-	          const hoisted = IN_PLACE ? childNodes[i] : cloneNode(childNodes[i], true);
+	          const hoisted = currentNode === root ? cloneNode(childNodes[i], true) : childNodes[i];
 	          parentNode.insertBefore(hoisted, getNextSibling(currentNode));
 	        }
 	      }
@@ -9918,6 +10562,26 @@ function requirePurify_cjs () {
 	    _forceRemove(currentNode);
 	    return true;
 	  };
+	  /**
+	   * Fork a hook-mutable allowlist off its shared binding the first time a
+	   * (possibly lazily-installed) uponSanitize* hook is about to see it, so the
+	   * hook cannot widen the per-instance default or the setConfig binding by
+	   * reference and leak past the call. Returns the set unchanged once it is
+	   * already call-local, so repeated calls across elements are idempotent.
+	   *
+	   * @param hookList the uponSanitize* hook array for this event
+	   * @param set the current ALLOWED_TAGS / ALLOWED_ATTR binding
+	   * @param defaultSet the per-instance DEFAULT_ALLOWED_* constant
+	   * @param setConfigSet the captured setConfig() binding, or null
+	   * @return a call-local clone if a hook is present and set is still shared,
+	   *   else set unchanged
+	   */
+	  const _forkSharedAllowlist = function _forkSharedAllowlist(hookList, set, defaultSet, setConfigSet) {
+	    if (hookList.length === 0) {
+	      return set;
+	    }
+	    return set === defaultSet || set === setConfigSet ? clone(set) : set;
+	  };
 	  /**
 	   * _sanitizeElements
 	   *
@@ -9927,9 +10591,20 @@ function requirePurify_cjs () {
 	   * @param currentNode to check for permission to exist
 	   * @return true if node was killed, false if left alive
 	   */
-	  const _sanitizeElements = function _sanitizeElements(currentNode) {
+	  // eslint-disable-next-line complexity
+	  const _sanitizeElements = function _sanitizeElements(currentNode, root) {
 	    /* Execute a hook if present */
 	    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+	    /* A hook may have detached the node - treat it as removed (see the
+	       detached-node comment after the uponSanitizeElement hook below). On
+	       the IN_PLACE path, neutralize the detached subtree first so a queued
+	       resource handler on it cannot fire in page scope after we return. */
+	    if (currentNode !== root && getParentNode(currentNode) === null) {
+	      if (IN_PLACE) {
+	        _neutralizeSubtree(currentNode);
+	      }
+	      return true;
+	    }
 	    /* Check if element is clobbered or can clobber */
 	    if (_isClobbered(currentNode)) {
 	      _forceRemove(currentNode);
@@ -9937,11 +10612,47 @@ function requirePurify_cjs () {
 	    }
 	    /* Now let's check the element's type and name */
 	    const tagName = transformCaseFunc(getNodeName ? getNodeName(currentNode) : currentNode.nodeName);
+	    /* Close the pre-walk clone-guard's timing gap: an uponSanitizeElement
+	       hook may have been installed after that guard sampled the hook arrays
+	       (e.g. lazily from beforeSanitizeElements), leaving ALLOWED_TAGS still
+	       aliasing a shared binding that a widening hook would mutate by
+	       reference. Fork it before exposing it to the hook. */
+	    ALLOWED_TAGS = _forkSharedAllowlist(hooks.uponSanitizeElement, ALLOWED_TAGS, DEFAULT_ALLOWED_TAGS, SET_CONFIG_ALLOWED_TAGS);
 	    /* Execute a hook if present */
 	    _executeHooks(hooks.uponSanitizeElement, currentNode, {
 	      tagName,
 	      allowedTags: ALLOWED_TAGS
 	    });
+	    /* A hook may have detached the node from the tree — a long-standing
+	       user pattern (issue #469; draw.io-style foreignObject filtering).
+	       Per the cached, unclobberable parentNode getter the node is
+	       genuinely out of the tree, so it can reach neither the serialized
+	       output nor an IN_PLACE live tree; treat it as removed and stop
+	       processing it. Without this guard, the unsafe-node / namespace
+	       checks below would call _forceRemove on a parentless node and hit
+	       the REPORT-3 fail-closed throw — which exists for nodes DOMPurify
+	       wants gone but *cannot* detach (clobbered / parentless roots), the
+	       opposite of a node that is already safely gone. The walk root is
+	       exempt: a detached IN_PLACE root is legitimate input and must still
+	       be fully sanitized, and a kill-decision on it must keep hitting the
+	       REPORT-3 throw. Nodes detached by hooks stay the hook's
+	       responsibility for placement: they are not recorded in
+	       DOMPurify.removed, so the post-walk IN_PLACE pass (which iterates
+	       DOMPurify.removed) does not reach them. But a hook-detached subtree
+	       can still hold a queued resource-event handler - e.g. an <img onload>
+	       that began loading when the caller built the live tree - which fires
+	       in page scope after sanitize returns even though the handler never
+	       reached the returned tree. That is the audit-5 F1 hazard, and the
+	       documented node.remove() hook pattern walks straight into it. So on
+	       the IN_PLACE path we neutralize the detached subtree inline here,
+	       stripping its non-allow-listed attributes before returning, exactly
+	       as the post-walk pass does for _forceRemove'd subtrees. */
+	    if (currentNode !== root && getParentNode(currentNode) === null) {
+	      if (IN_PLACE) {
+	        _neutralizeSubtree(currentNode);
+	      }
+	      return true;
+	    }
 	    /* Remove mXSS vectors, processing instructions and risky comments */
 	    if (_isUnsafeNode(currentNode, tagName)) {
 	      _forceRemove(currentNode);
@@ -9949,7 +10660,22 @@ function requirePurify_cjs () {
 	    }
 	    /* Remove element if anything forbids its presence */
 	    if (FORBID_TAGS[tagName] || !(EXTRA_ELEMENT_HANDLING.tagCheck instanceof Function && EXTRA_ELEMENT_HANDLING.tagCheck(tagName)) && !ALLOWED_TAGS[tagName]) {
-	      return _sanitizeDisallowedNode(currentNode, tagName);
+	      const removed = _sanitizeDisallowedNode(currentNode, tagName, root);
+	      /* A false return means the node is a custom element kept via
+	         CUSTOM_ELEMENT_HANDLING - the only keep path through
+	         _sanitizeDisallowedNode. Run afterSanitizeElements on it so the
+	         element-hook lifecycle matches normal allowlisted elements: a
+	         security policy applied in this hook (e.g. stripping an attribute
+	         from every surviving element) must not silently skip kept custom
+	         elements (GHSA-c2j3-45gr-mqc4). This mirrors the normal-element
+	         tail below - the hook runs, then the walker's subsequent
+	         _sanitizeAttributes pass sanitizes the element's attributes. The
+	         deliberately skipped namespace and fallback-tag removal checks stay
+	         skipped; they are removal decisions, not the hook contract. */
+	      if (removed === false) {
+	        _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+	      }
+	      return removed;
 	    }
 	    /* Check whether element has a valid namespace.
 	       Realm-safe check (GHSA-hpcv-96wg-7vj8): use the cached Node.prototype
@@ -9996,6 +10722,33 @@ function requirePurify_cjs () {
 	    if (FORBID_ATTR[lcName]) {
 	      return false;
 	    }
+	    /* Reject declarative-partial-updates patch-linkage attributes
+	       (https://github.com/WICG/declarative-partial-updates).
+	            Empirical note (Chrome 150, verified — see
+	       test/declarative-patch-probe-v3.html): expansion is NOT applied after
+	       sanitization. For the string path it fires during sanitize()'s own
+	       parse, so the walk sees and sanitizes the fully materialized expanded
+	       tree — teleports into MathML/SVG integration points included; a
+	       weaponized `<template for>`->`<img onerror>` comes back with the handler
+	       stripped. For the IN_PLACE path it fires on connection, before the walk.
+	       Either way DOMPurify is NOT blind to the patch.
+	            This removal is therefore defense-in-depth rather than the sole barrier:
+	       it prevents live linkage from surviving into the OUTPUT and re-expanding
+	       in the caller's context, and keeps behaviour deterministic if a future
+	       engine defers expansion. `for` is legitimate only on <label>/<output>;
+	       anywhere else (notably <template for>) it links the element to a patch
+	       target and teleports or removes an arbitrary DOM range by id/marker name.
+	       `patchsrc` fetches remote markup and is treated as a script-loading
+	       mechanism (CSP). Gated on SAFE_FOR_XML so the removal groups with the
+	       other structural-threat checks and stays overridable, consistent with
+	       the rest of the codebase. PI range markers are already removed by
+	       _isUnsafeNode. */
+	    if (SAFE_FOR_XML && lcName === 'patchsrc') {
+	      return false;
+	    }
+	    if (SAFE_FOR_XML && lcName === 'for' && lcTag !== 'label' && lcTag !== 'output') {
+	      return false;
+	    }
 	    /* Make sure attribute cannot clobber */
 	    if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
 	      return false;
@@ -10112,6 +10865,9 @@ function requirePurify_cjs () {
 	    if (!attributes || _isClobbered(currentNode)) {
 	      return;
 	    }
+	    /* Same lazy-install guard as uponSanitizeElement (see there): fork the
+	       attribute allowlist off its shared binding before a hook can see it. */
+	    ALLOWED_ATTR = _forkSharedAllowlist(hooks.uponSanitizeAttribute, ALLOWED_ATTR, DEFAULT_ALLOWED_ATTR, SET_CONFIG_ALLOWED_ATTR);
 	    const hookEvent = {
 	      attrName: '',
 	      attrValue: '',
@@ -10205,7 +10961,7 @@ function requirePurify_cjs () {
 	      /* Execute a hook if present */
 	      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
 	      /* Sanitize tags and elements */
-	      _sanitizeElements(shadowNode);
+	      _sanitizeElements(shadowNode, fragment);
 	      /* Check attributes next */
 	      _sanitizeAttributes(shadowNode);
 	      /* Deep shadow DOM detected.
@@ -10396,6 +11152,11 @@ function requirePurify_cjs () {
 	       keep using and whose return value they ignore — unsanitized. REPORT-2. */
 	    const inPlace = IN_PLACE && typeof dirty !== 'string' && _isNode(dirty);
 	    if (inPlace) {
+	      /* Declarative-partial-updates / streaming pre-pass: sever every patch
+	         linkage across the live tree BEFORE the walk, so no patch can fire
+	         mid-walk and inject into an already-processed region. Runs first, so
+	         it also covers the forbidden/clobbered roots that throw below. */
+	      _neutralizePatchLinkage(dirty);
 	      /* Do some early pre-sanitization to avoid unsafe root nodes.
 	         Read nodeName through the cached prototype getter — a clobbering
 	         child named "nodeName" on the form root would otherwise shadow
@@ -10405,6 +11166,9 @@ function requirePurify_cjs () {
 	      if (typeof nn === 'string') {
 	        const tagName = transformCaseFunc(nn);
 	        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+	          /* Fail closed on a live root: neutralize handlers/children before
+	             throwing, exactly as the mid-walk abort path does. */
+	          _neutralizeRoot(dirty);
 	          throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
 	        }
 	      }
@@ -10419,6 +11183,10 @@ function requirePurify_cjs () {
 	         the application unsanitized. Refuse to sanitize such a root
 	         the same way we refuse a forbidden tag. GHSA-r47g-fvhr-h676. */
 	      if (_isClobbered(dirty)) {
+	        /* Fail closed on a live clobbered root before throwing.
+	           _neutralizeRoot's reads are clobber-safe (cached getters); the
+	           form's non-clobbered descendants, e.g. an armed <img>, are scrubbed. */
+	        _neutralizeRoot(dirty);
 	        throw typeErrorCreate('root node is clobbered and cannot be sanitized in-place');
 	      }
 	      /* Sanitize attached shadow roots before the main iterator runs.
@@ -10471,20 +11239,24 @@ function requirePurify_cjs () {
 	      _forceRemove(body.firstChild);
 	    }
 	    /* Get node iterator */
-	    const nodeIterator = _createNodeIterator(inPlace ? dirty : body);
+	    const walkRoot = inPlace ? dirty : body;
 	    /* Now start iterating over the created document.
 	       The walk runs inside an exception barrier (campaign-3 F2): a re-entrant
 	       engine/custom-element mutation can detach a node mid-walk so
 	       `_forceRemove`'s parentless guard throws, aborting the loop. Without the
 	       barrier the caller's in-place tree would be left half-sanitized with the
-	       unvisited tail still armed. On any throw we fail closed — strip the
-	       in-place root bare — then rethrow so the existing throw contract is
-	       preserved. (String/DOM-copy paths never return the partial body, so the
-	       propagating throw is already fail-closed there.) */
+	       unvisited tail still armed. _createNodeIterator itself is inside the
+	       barrier too: constructing the iterator dereferences the root's document,
+	       and any failure there (e.g. an exotic/clobbered root) must still fail
+	       closed rather than skip the neutralize. On any throw we fail closed -
+	       strip the in-place root bare - then rethrow so the existing throw
+	       contract is preserved. (String/DOM-copy paths never return the partial
+	       body, so the propagating throw is already fail-closed there.) */
 	    try {
+	      const nodeIterator = _createNodeIterator(walkRoot);
 	      while (currentNode = nodeIterator.nextNode()) {
 	        /* Sanitize tags and elements */
-	        _sanitizeElements(currentNode);
+	        _sanitizeElements(currentNode, walkRoot);
 	        /* Check attributes next */
 	        _sanitizeAttributes(currentNode);
 	        /* Shadow DOM detected, sanitize it.
@@ -10498,6 +11270,14 @@ function requirePurify_cjs () {
 	    } catch (error) {
 	      if (inPlace) {
 	        _neutralizeRoot(dirty);
+	        /* Nodes _forceRemove'd earlier in the aborted walk are already
+	           detached from the root, so _neutralizeRoot's subtree pass does not
+	           reach them. Defuse them too, mirroring the success-path loop below. */
+	        arrayForEach(DOMPurify.removed, entry => {
+	          if (entry.element) {
+	            _neutralizeSubtree(entry.element);
+	          }
+	        });
 	      }
 	      throw error;
 	    }
@@ -14924,6 +15704,54 @@ var MultiWidget = /*#__PURE__*/function () {
         validate_card_types: validateCardNumberInput
       });
     }
+    /**
+     * Current method restricts which card schemes the card number input accepts, without changing which card
+     * icons the widget displays. Scheme identifiers are matched case-insensitively and ignoring surrounding
+     * whitespace; unsupported identifiers are ignored with a warning, so a list in which every identifier is
+     * unsupported applies no restriction at all.
+     *
+     * Takes precedence over setSupportedCardIcons: when a non-empty list is supplied here, it is the only list
+     * used for validation and the validateCardNumberInput flag of setSupportedCardIcons no longer affects it.
+     * Calling this method more than once replaces the previous list rather than merging with it.
+     *
+     * Must be called before load().
+     *
+     * @example
+     *
+     * widget.setAllowedCardSchemes(['visa', 'mastercard']);
+     *
+     * @param {string[]} schemes - [CARD_SCHEME]{@link CARD_SCHEME}
+     */
+  }, {
+    key: "setAllowedCardSchemes",
+    value: function setAllowedCardSchemes(schemes) {
+      var vocabulary = ObjectHelper.values(CARD_SCHEME);
+      var allowedSchemes = [];
+      var _iterator = _createForOfIteratorHelper(Array.isArray(schemes) ? schemes : []),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var entry = _step.value;
+          var scheme = typeof entry === 'string' ? entry.trim().toLowerCase() : '';
+          if (vocabulary.indexOf(scheme) === -1) {
+            console.warn("Widget::setAllowedCardSchemes: unsupported card scheme ".concat(entry));
+            continue;
+          }
+          if (allowedSchemes.indexOf(scheme) === -1) {
+            allowedSchemes.push(scheme);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (allowedSchemes.length) {
+        this.link.setParams({
+          allowed_card_schemes: allowedSchemes.join(',')
+        });
+      }
+    }
     /**
      * Current method can hide prevent the widget from showing the error messages
      *
@@ -45284,14 +46112,17 @@ var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };
 var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };
 // read zip header
 var zh = function (d, b, z) {
-    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
-    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
-    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];
+    var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);
+    var _a = z && bs == 4294967295 ? z64e(d, es, efl) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];
+    return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off];
 };
 // read zip64 extra field
-var z64e = function (d, b) {
-    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))
-        ;
+var z64e = function (d, b, l) {
+    var e = b + l;
+    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2)) {
+        if (b + 4 > e)
+            err(13);
+    }
     return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];
 };
 // extra field length
@@ -45894,7 +46725,7 @@ var Unzip = /*#__PURE__*/ (function () {
                         var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);
                         var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);
                         if (sc_1 == 4294967295) {
-                            _a = dd ? [-2] : z64e(buf, i), sc_1 = _a[0], su_1 = _a[1];
+                            _a = dd ? [-2] : z64e(buf, i, es), sc_1 = _a[0], su_1 = _a[1];
                         }
                         else if (dd)
                             sc_1 = -1;
@@ -46175,6 +47006,7 @@ exports.Api = Api;
 exports.ApplePayOpenWalletButton = ApplePayOpenWalletButton;
 exports.ApplePayWalletButtonExpress = ApplePayWalletButtonExpress;
 exports.CANVAS_3DS_EVENT = CANVAS_3DS_EVENT;
+exports.CARD_SCHEME = CARD_SCHEME;
 exports.CHECKOUT_BUTTON_EVENT = CHECKOUT_BUTTON_EVENT;
 exports.CHECKOUT_EVENT = EVENT$2;
 exports.Canvas3ds = Canvas3ds;