siarashield_workspace 0.0.30 → 0.0.32

package/esm2022/lib/siara-shield.component.mjs

@@ -0,0 +1,196 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { getInitCaptchaFn, getSiaraShieldGlobals } from './siara-shield.globals';
+import { installVendorRuntimeErrorSuppression, suppressVendorConsoleWindow } from './siara-shield-log-utils';
+import { prepareScriptNonce } from './siara-shield-script-utils';
+import { installCaptchaSubmitGuard } from './siara-shield-submit-guard';
+import * as i0 from "@angular/core";
+import * as i1 from "./siara-shield-loader.service";
+const JQUERY_FALLBACK_SRC = 'https://embedcdn.mycybersiara.com/capcha-temple/js/jquery.min.js';
+const CAPTCHA_SCRIPT_SRC = 'https://embedcdn.mycybersiara.com/CaptchaFormate/CaptchaResources.js';
+const VALIDATION_SCRIPT_SRC = 'https://embed.mycybersiara.com/CaptchaFormate/SiaraShield_Validation.js';
+const CAPTCHA_READY_TIMEOUT_MS = 8000;
+function ensureAccessibilityPopupAliases() {
+    const g = globalThis;
+    const aliasNames = [
+        'RemoveAccesibilityPopup',
+        '_RemoveAccesibilityPopup',
+        'RemoveAccesiblityPopup',
+        '_RemoveAccesiblityPopup',
+    ];
+    const existing = aliasNames
+        .map((name) => g[name])
+        .find((value) => typeof value === 'function');
+    const stableFn = existing ?? (() => undefined);
+    for (const name of aliasNames) {
+        g[name] = stableFn;
+    }
+}
+function runInRootZone(fn) {
+    const g = globalThis;
+    const zoneRootRun = g.Zone?.root?.run;
+    if (typeof zoneRootRun === 'function') {
+        return zoneRootRun.call(g.Zone?.root, fn);
+    }
+    return fn();
+}
+export class SiaraShieldComponent {
+    host;
+    loader;
+    publicKey;
+    loadJQuery = true;
+    cspNonce;
+    allowVendorConsoleLogs = false;
+    /**
+     * Emits the current `CyberSiaraToken` right after a successful `checkCaptcha()`.
+     */
+    token = new EventEmitter();
+    initialized = false;
+    constructor(host, loader) {
+        this.host = host;
+        this.loader = loader;
+    }
+    async ngAfterViewInit() {
+        await this.init({
+            publicKey: this.publicKey,
+            loadJQuery: this.loadJQuery,
+            cspNonce: this.cspNonce,
+            allowVendorConsoleLogs: this.allowVendorConsoleLogs,
+        });
+    }
+    async init(options) {
+        if (this.initialized)
+            return;
+        // Ensure the host element is in DOM before scripts run.
+        void this.host.nativeElement;
+        installCaptchaSubmitGuard();
+        if (!options.publicKey) {
+            throw new Error('SiaraShieldComponent: publicKey is required.');
+        }
+        const cspNonce = prepareScriptNonce(this.host.nativeElement.ownerDocument, options.cspNonce);
+        if ((options.loadJQuery ?? true) && !this.isJQueryAlreadyAvailable()) {
+            await this.loader.loadScript(JQUERY_FALLBACK_SRC, { nonce: cspNonce });
+        }
+        await this.loader.loadScript(CAPTCHA_SCRIPT_SRC, {
+            nonce: cspNonce,
+        });
+        await this.loader.loadScript(VALIDATION_SCRIPT_SRC, {
+            nonce: cspNonce,
+        });
+        const g = getSiaraShieldGlobals();
+        ensureAccessibilityPopupAliases();
+        this.preventDuplicateValidationBootstrap(g);
+        const initCaptchaFn = getInitCaptchaFn(g);
+        if (!initCaptchaFn) {
+            throw new Error('SiaraShield: InitCaptcha() is not available after loading scripts. Check whether CSP blocked vendor scripts or inline execution.');
+        }
+        if (!options.allowVendorConsoleLogs) {
+            suppressVendorConsoleWindow();
+            installVendorRuntimeErrorSuppression();
+        }
+        runInRootZone(() => initCaptchaFn(options.publicKey));
+        await this.waitForCheckCaptchaApi();
+        this.initialized = true;
+    }
+    /**
+     * Detect preloaded jQuery from global object or an existing script tag.
+     */
+    isJQueryAlreadyAvailable() {
+        const g = getSiaraShieldGlobals();
+        if (typeof g.jQuery === 'function' || typeof g.$ === 'function') {
+            return true;
+        }
+        const existingJqueryScript = this.host.nativeElement.ownerDocument.querySelector('script[src*="jquery"]');
+        return Boolean(existingJqueryScript);
+    }
+    preventDuplicateValidationBootstrap(g) {
+        const originalAppendValidation = g.AppendValidationJS;
+        if (typeof originalAppendValidation !== 'function') {
+            return;
+        }
+        g.AppendValidationJS = () => {
+            const existing = this.host.nativeElement.ownerDocument.querySelector(`script[src="${VALIDATION_SCRIPT_SRC}"]`);
+            if (existing) {
+                return;
+            }
+            originalAppendValidation();
+        };
+    }
+    async waitForCheckCaptchaApi(timeoutMs = CAPTCHA_READY_TIMEOUT_MS) {
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            if (getSiaraShieldGlobals().CheckCaptcha) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        throw new Error('SiaraShield: CheckCaptcha() was not available within timeout. This can happen when CSP blocks the captcha runtime.');
+    }
+    /**
+     * Calls the global `CheckCaptcha()` from SiaraShield script.
+     * Returns true when captcha is valid; emits token if available.
+     */
+    checkCaptcha() {
+        const g = getSiaraShieldGlobals();
+        if (!g.CheckCaptcha) {
+            throw new Error('SiaraShield: CheckCaptcha() is not available. Did init() run, and is CSP allowing the captcha scripts?');
+        }
+        if (!this.allowVendorConsoleLogs) {
+            suppressVendorConsoleWindow();
+        }
+        const ok = g.CheckCaptcha();
+        if (ok && typeof g.CyberSiaraToken === 'string') {
+            this.token.emit(g.CyberSiaraToken);
+        }
+        return ok;
+    }
+    /**
+     * Async-friendly captcha validation to avoid first-click timing issues.
+     * Performs one validation call and waits for token propagation.
+     */
+    async checkCaptchaAsync(options) {
+        const timeoutMs = options?.timeoutMs ?? 2000;
+        const pollIntervalMs = options?.pollIntervalMs ?? 120;
+        const beforeCheckDelayMs = options?.beforeCheckDelayMs ?? 140;
+        await new Promise((resolve) => setTimeout(resolve, beforeCheckDelayMs));
+        const ok = this.checkCaptcha();
+        if (!ok)
+            return false;
+        const g = getSiaraShieldGlobals();
+        if (typeof g.CyberSiaraToken === 'string' && g.CyberSiaraToken.length > 0) {
+            return true;
+        }
+        const startedAt = Date.now();
+        while (Date.now() - startedAt < timeoutMs) {
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+            const token = getSiaraShieldGlobals().CyberSiaraToken;
+            if (typeof token === 'string' && token.length > 0) {
+                this.token.emit(token);
+                return true;
+            }
+        }
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldComponent, deps: [{ token: i0.ElementRef }, { token: i1.SiaraShieldLoaderService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SiaraShieldComponent, isStandalone: true, selector: "siara-shield", inputs: { publicKey: "publicKey", loadJQuery: "loadJQuery", cspNonce: "cspNonce", allowVendorConsoleLogs: "allowVendorConsoleLogs" }, outputs: { token: "token" }, ngImport: i0, template: `<div class="SiaraShield"></div>`, isInline: true, encapsulation: i0.ViewEncapsulation.None });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'siara-shield',
+                    standalone: true,
+                    template: `<div class="SiaraShield"></div>`,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.SiaraShieldLoaderService }], propDecorators: { publicKey: [{
+                type: Input,
+                args: [{ required: true }]
+            }], loadJQuery: [{
+                type: Input
+            }], cspNonce: [{
+                type: Input
+            }], allowVendorConsoleLogs: [{
+                type: Input
+            }], token: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"siara-shield.component.js","sourceRoot":"","sources":["../../../../projects/siarashield-workspace/src/lib/siara-shield.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, Component, ElementRef, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';\nimport { SiaraShieldLoaderService } from './siara-shield-loader.service';\nimport { getInitCaptchaFn, getSiaraShieldGlobals } from './siara-shield.globals';\nimport { installVendorRuntimeErrorSuppression, suppressVendorConsoleWindow } from './siara-shield-log-utils';\nimport { prepareScriptNonce } from './siara-shield-script-utils';\nimport { installCaptchaSubmitGuard } from './siara-shield-submit-guard';\n\nconst JQUERY_FALLBACK_SRC = 'https://embedcdn.mycybersiara.com/capcha-temple/js/jquery.min.js';\nconst CAPTCHA_SCRIPT_SRC = 'https://embedcdn.mycybersiara.com/CaptchaFormate/CaptchaResources.js';\nconst VALIDATION_SCRIPT_SRC = 'https://embed.mycybersiara.com/CaptchaFormate/SiaraShield_Validation.js';\nconst CAPTCHA_READY_TIMEOUT_MS = 8000;\n\nfunction ensureAccessibilityPopupAliases(): void {\n  const g = globalThis as typeof globalThis & Record<string, unknown>;\n  const aliasNames = [\n    'RemoveAccesibilityPopup',\n    '_RemoveAccesibilityPopup',\n    'RemoveAccesiblityPopup',\n    '_RemoveAccesiblityPopup',\n  ] as const;\n\n  const existing = aliasNames\n    .map((name) => g[name])\n    .find((value): value is () => void => typeof value === 'function');\n\n  const stableFn = existing ?? (() => undefined);\n  for (const name of aliasNames) {\n    g[name] = stableFn;\n  }\n}\n\nfunction runInRootZone<T>(fn: () => T): T {\n  const g = globalThis as typeof globalThis & { Zone?: { root?: { run?: <U>(cb: () => U) => U } } };\n  const zoneRootRun = g.Zone?.root?.run;\n  if (typeof zoneRootRun === 'function') {\n    return zoneRootRun.call(g.Zone?.root, fn) as T;\n  }\n  return fn();\n}\n\nexport interface SiaraShieldInitOptions {\n  /** SiaraShield public key. Use \"TEST-CYBERSIARA\" for staging/development. */\n  publicKey: string;\n  /** Loads jQuery before SiaraShield script. Default is true for easier integration. Set to false only if your page already includes jQuery. */\n  loadJQuery?: boolean;\n  /** CSP nonce for strict policies (`script-src 'nonce-...'`). Pair with `getSiaraShieldCspPolicy()`. */\n  cspNonce?: string;\n  /** Set true only when actively debugging vendor/runtime internals in browser console. */\n  allowVendorConsoleLogs?: boolean;\n}\n\n@Component({\n  selector: 'siara-shield',\n  standalone: true,\n  template: `<div class=\"SiaraShield\"></div>`,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class SiaraShieldComponent implements AfterViewInit {\n  @Input({ required: true }) publicKey!: string;\n  @Input() loadJQuery = true;\n  @Input() cspNonce?: string;\n  @Input() allowVendorConsoleLogs = false;\n\n  /**\n   * Emits the current `CyberSiaraToken` right after a successful `checkCaptcha()`.\n   */\n  @Output() token = new EventEmitter<string>();\n\n  private initialized = false;\n\n  constructor(\n    private readonly host: ElementRef<HTMLElement>,\n    private readonly loader: SiaraShieldLoaderService,\n  ) {}\n\n  async ngAfterViewInit(): Promise<void> {\n    await this.init({\n      publicKey: this.publicKey,\n      loadJQuery: this.loadJQuery,\n      cspNonce: this.cspNonce,\n      allowVendorConsoleLogs: this.allowVendorConsoleLogs,\n    });\n  }\n\n  async init(options: SiaraShieldInitOptions): Promise<void> {\n    if (this.initialized) return;\n\n    // Ensure the host element is in DOM before scripts run.\n    void this.host.nativeElement;\n    installCaptchaSubmitGuard();\n\n    if (!options.publicKey) {\n      throw new Error('SiaraShieldComponent: publicKey is required.');\n    }\n    const cspNonce = prepareScriptNonce(this.host.nativeElement.ownerDocument, options.cspNonce);\n\n    if ((options.loadJQuery ?? true) && !this.isJQueryAlreadyAvailable()) {\n      await this.loader.loadScript(JQUERY_FALLBACK_SRC, { nonce: cspNonce });\n    }\n\n    await this.loader.loadScript(CAPTCHA_SCRIPT_SRC, {\n      nonce: cspNonce,\n    });\n    await this.loader.loadScript(VALIDATION_SCRIPT_SRC, {\n      nonce: cspNonce,\n    });\n\n    const g = getSiaraShieldGlobals();\n    ensureAccessibilityPopupAliases();\n    this.preventDuplicateValidationBootstrap(g);\n    const initCaptchaFn = getInitCaptchaFn(g);\n    if (!initCaptchaFn) {\n      throw new Error(\n        'SiaraShield: InitCaptcha() is not available after loading scripts. Check whether CSP blocked vendor scripts or inline execution.',\n      );\n    }\n\n    if (!options.allowVendorConsoleLogs) {\n      suppressVendorConsoleWindow();\n      installVendorRuntimeErrorSuppression();\n    }\n    runInRootZone(() => initCaptchaFn(options.publicKey));\n    await this.waitForCheckCaptchaApi();\n    this.initialized = true;\n  }\n\n  /**\n   * Detect preloaded jQuery from global object or an existing script tag.\n   */\n  private isJQueryAlreadyAvailable(): boolean {\n    const g = getSiaraShieldGlobals();\n    if (typeof g.jQuery === 'function' || typeof g.$ === 'function') {\n      return true;\n    }\n\n    const existingJqueryScript = this.host.nativeElement.ownerDocument.querySelector<HTMLScriptElement>(\n      'script[src*=\"jquery\"]',\n    );\n    return Boolean(existingJqueryScript);\n  }\n\n  private preventDuplicateValidationBootstrap(g: ReturnType<typeof getSiaraShieldGlobals>): void {\n    const originalAppendValidation = g.AppendValidationJS;\n    if (typeof originalAppendValidation !== 'function') {\n      return;\n    }\n\n    g.AppendValidationJS = () => {\n      const existing = this.host.nativeElement.ownerDocument.querySelector<HTMLScriptElement>(\n        `script[src=\"${VALIDATION_SCRIPT_SRC}\"]`,\n      );\n      if (existing) {\n        return;\n      }\n\n      originalAppendValidation();\n    };\n  }\n\n  private async waitForCheckCaptchaApi(timeoutMs = CAPTCHA_READY_TIMEOUT_MS): Promise<void> {\n    const startedAt = Date.now();\n    while (Date.now() - startedAt < timeoutMs) {\n      if (getSiaraShieldGlobals().CheckCaptcha) {\n        return;\n      }\n      await new Promise((resolve) => setTimeout(resolve, 100));\n    }\n    throw new Error('SiaraShield: CheckCaptcha() was not available within timeout. This can happen when CSP blocks the captcha runtime.');\n  }\n\n  /**\n   * Calls the global `CheckCaptcha()` from SiaraShield script.\n   * Returns true when captcha is valid; emits token if available.\n   */\n  checkCaptcha(): boolean {\n    const g = getSiaraShieldGlobals();\n    if (!g.CheckCaptcha) {\n      throw new Error('SiaraShield: CheckCaptcha() is not available. Did init() run, and is CSP allowing the captcha scripts?');\n    }\n\n    if (!this.allowVendorConsoleLogs) {\n      suppressVendorConsoleWindow();\n    }\n    const ok = g.CheckCaptcha();\n    if (ok && typeof g.CyberSiaraToken === 'string') {\n      this.token.emit(g.CyberSiaraToken);\n    }\n    return ok;\n  }\n\n  /**\n   * Async-friendly captcha validation to avoid first-click timing issues.\n   * Performs one validation call and waits for token propagation.\n   */\n  async checkCaptchaAsync(options?: { timeoutMs?: number; pollIntervalMs?: number; beforeCheckDelayMs?: number }): Promise<boolean> {\n    const timeoutMs = options?.timeoutMs ?? 2000;\n    const pollIntervalMs = options?.pollIntervalMs ?? 120;\n    const beforeCheckDelayMs = options?.beforeCheckDelayMs ?? 140;\n    await new Promise((resolve) => setTimeout(resolve, beforeCheckDelayMs));\n    const ok = this.checkCaptcha();\n    if (!ok) return false;\n\n    const g = getSiaraShieldGlobals();\n    if (typeof g.CyberSiaraToken === 'string' && g.CyberSiaraToken.length > 0) {\n      return true;\n    }\n\n    const startedAt = Date.now();\n    while (Date.now() - startedAt < timeoutMs) {\n      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));\n      const token = getSiaraShieldGlobals().CyberSiaraToken;\n      if (typeof token === 'string' && token.length > 0) {\n        this.token.emit(token);\n        return true;\n      }\n    }\n\n    return true;\n  }\n}\n\n"]}

package/esm2022/lib/siara-shield.globals.mjs

@@ -0,0 +1,7 @@
+export function getSiaraShieldGlobals() {
+    return globalThis;
+}
+export function getInitCaptchaFn(g) {
+    return g.initCaptcha ?? g.InitCaptcha;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lhcmEtc2hpZWxkLmdsb2JhbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9zaWFyYXNoaWVsZC13b3Jrc3BhY2Uvc3JjL2xpYi9zaWFyYS1zaGllbGQuZ2xvYmFscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFhQSxNQUFNLFVBQVUscUJBQXFCO0lBQ25DLE9BQVEsVUFBd0UsQ0FBQztBQUNuRixDQUFDO0FBRUQsTUFBTSxVQUFVLGdCQUFnQixDQUFDLENBQXFCO0lBQ3BELE9BQU8sQ0FBQyxDQUFDLFdBQVcsSUFBSSxDQUFDLENBQUMsV0FBVyxDQUFDO0FBQ3hDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBJbml0Q2FwdGNoYUZuID0gKHB1YmxpY0tleTogc3RyaW5nKSA9PiB2b2lkO1xuZXhwb3J0IHR5cGUgQ2hlY2tDYXB0Y2hhRm4gPSAoKSA9PiBib29sZWFuO1xuXG5leHBvcnQgaW50ZXJmYWNlIFNpYXJhU2hpZWxkR2xvYmFscyB7XG4gIGluaXRDYXB0Y2hhPzogSW5pdENhcHRjaGFGbjtcbiAgSW5pdENhcHRjaGE/OiBJbml0Q2FwdGNoYUZuO1xuICBDaGVja0NhcHRjaGE/OiBDaGVja0NhcHRjaGFGbjtcbiAgQXBwZW5kVmFsaWRhdGlvbkpTPzogKCkgPT4gdm9pZDtcbiAgQ3liZXJTaWFyYVRva2VuPzogc3RyaW5nO1xuICBqUXVlcnk/OiB1bmtub3duO1xuICAkPzogdW5rbm93bjtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldFNpYXJhU2hpZWxkR2xvYmFscygpOiBTaWFyYVNoaWVsZEdsb2JhbHMge1xuICByZXR1cm4gKGdsb2JhbFRoaXMgYXMgdW5rbm93biBhcyB7IFtrOiBzdHJpbmddOiB1bmtub3duIH0pIGFzIFNpYXJhU2hpZWxkR2xvYmFscztcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldEluaXRDYXB0Y2hhRm4oZzogU2lhcmFTaGllbGRHbG9iYWxzKTogSW5pdENhcHRjaGFGbiB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiBnLmluaXRDYXB0Y2hhID8/IGcuSW5pdENhcHRjaGE7XG59XG4iXX0=

package/esm2022/lib/siara-shield.mjs

@@ -0,0 +1,156 @@
+import { getInitCaptchaFn, getSiaraShieldGlobals } from './siara-shield.globals';
+import { installVendorRuntimeErrorSuppression, suppressVendorConsoleWindow } from './siara-shield-log-utils';
+import { loadScript, prepareScriptNonce } from './siara-shield-script-utils';
+import { installCaptchaSubmitGuard } from './siara-shield-submit-guard';
+const JQUERY_FALLBACK_SRC = 'https://embedcdn.mycybersiara.com/capcha-temple/js/jquery.min.js';
+const CAPTCHA_SCRIPT_SRC = 'https://embedcdn.mycybersiara.com/CaptchaFormate/CaptchaResources.js';
+const VALIDATION_SCRIPT_SRC = 'https://embed.mycybersiara.com/CaptchaFormate/SiaraShield_Validation.js';
+const CAPTCHA_READY_TIMEOUT_MS = 8000;
+let pending = null;
+let initialized = false;
+function ensureAccessibilityPopupAliases() {
+    const g = globalThis;
+    const aliasNames = [
+        'RemoveAccesibilityPopup',
+        '_RemoveAccesibilityPopup',
+        'RemoveAccesiblityPopup',
+        '_RemoveAccesiblityPopup',
+    ];
+    const existing = aliasNames
+        .map((name) => g[name])
+        .find((value) => typeof value === 'function');
+    const stableFn = existing ?? (() => undefined);
+    for (const name of aliasNames) {
+        g[name] = stableFn;
+    }
+}
+function isJQueryAlreadyAvailable() {
+    const g = getSiaraShieldGlobals();
+    if (typeof g.jQuery === 'function' || typeof g.$ === 'function') {
+        return true;
+    }
+    const existingJqueryScript = document.querySelector('script[src*="jquery"]');
+    return Boolean(existingJqueryScript);
+}
+function runInRootZone(fn) {
+    const g = globalThis;
+    const zoneRootRun = g.Zone?.root?.run;
+    if (typeof zoneRootRun === 'function') {
+        return zoneRootRun.call(g.Zone?.root, fn);
+    }
+    return fn();
+}
+function preventDuplicateValidationBootstrap(g) {
+    const originalAppendValidation = g.AppendValidationJS;
+    if (typeof originalAppendValidation !== 'function') {
+        return;
+    }
+    g.AppendValidationJS = () => {
+        const existing = document.querySelector(`script[src="${VALIDATION_SCRIPT_SRC}"]`);
+        if (existing) {
+            return;
+        }
+        originalAppendValidation();
+    };
+}
+async function waitForCheckCaptchaApi(timeoutMs = CAPTCHA_READY_TIMEOUT_MS) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        if (getSiaraShieldGlobals().CheckCaptcha) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error('SiaraShield: CheckCaptcha() was not available within timeout. This can happen when CSP blocks the captcha runtime.');
+}
+/**
+ * Drop-in initializer for SiaraShield.
+ * - Loads required scripts (optionally jQuery)
+ * - Calls global `initCaptcha(publicKey)`
+ *
+ * Requirements in your HTML/template:
+ * - You must render: `<div class="SiaraShield"></div>`
+ */
+export async function initSiaraShield(options) {
+    if (initialized)
+        return;
+    if (pending)
+        return pending;
+    if (!options?.publicKey) {
+        throw new Error('initSiaraShield: publicKey is required.');
+    }
+    pending = (async () => {
+        installCaptchaSubmitGuard();
+        const cspNonce = prepareScriptNonce(document, options.cspNonce);
+        if ((options.loadJQuery ?? true) && !isJQueryAlreadyAvailable()) {
+            await loadScript(document, JQUERY_FALLBACK_SRC, { nonce: cspNonce });
+        }
+        await loadScript(document, CAPTCHA_SCRIPT_SRC, {
+            nonce: cspNonce,
+        });
+        await loadScript(document, VALIDATION_SCRIPT_SRC, {
+            nonce: cspNonce,
+        });
+        const g = getSiaraShieldGlobals();
+        ensureAccessibilityPopupAliases();
+        preventDuplicateValidationBootstrap(g);
+        const initCaptchaFn = getInitCaptchaFn(g);
+        if (!initCaptchaFn) {
+            throw new Error('SiaraShield: InitCaptcha() is not available after loading scripts. Check whether CSP blocked vendor scripts or inline execution.');
+        }
+        if (!options.allowVendorConsoleLogs) {
+            suppressVendorConsoleWindow();
+            installVendorRuntimeErrorSuppression();
+        }
+        runInRootZone(() => initCaptchaFn(options.publicKey));
+        await waitForCheckCaptchaApi();
+        initialized = true;
+    })();
+    try {
+        await pending;
+    }
+    finally {
+        // keep `pending` cached for subsequent callers
+    }
+}
+/**
+ * Calls global `CheckCaptcha()` and returns its boolean result.
+ * If successful, returns `{ ok: true, token?: string }`.
+ */
+export function checkSiaraShieldCaptcha(options) {
+    const g = getSiaraShieldGlobals();
+    if (!g.CheckCaptcha) {
+        throw new Error('SiaraShield: CheckCaptcha() is not available. Did initSiaraShield() run, and is CSP allowing the captcha scripts?');
+    }
+    if (!options?.allowVendorConsoleLogs) {
+        suppressVendorConsoleWindow();
+    }
+    const ok = g.CheckCaptcha();
+    const token = typeof g.CyberSiaraToken === 'string' ? g.CyberSiaraToken : undefined;
+    return ok ? { ok: true, token } : { ok: false };
+}
+/**
+ * Async-friendly captcha check to handle delayed token population.
+ */
+export async function checkSiaraShieldCaptchaAsync(options) {
+    const timeoutMs = options?.timeoutMs ?? 1200;
+    const pollIntervalMs = options?.pollIntervalMs ?? 120;
+    const beforeCheckDelayMs = options?.beforeCheckDelayMs ?? 140;
+    await new Promise((resolve) => setTimeout(resolve, beforeCheckDelayMs));
+    const firstCheck = checkSiaraShieldCaptcha(); // one API call only
+    if (!firstCheck.ok)
+        return firstCheck;
+    if (firstCheck.token)
+        return firstCheck;
+    const startedAt = Date.now();
+    // Token can be assigned slightly after successful verification.
+    while (Date.now() - startedAt < timeoutMs) {
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        const token = getSiaraShieldGlobals().CyberSiaraToken;
+        if (typeof token === 'string' && token.length > 0) {
+            return { ok: true, token };
+        }
+    }
+    return { ok: true };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"siara-shield.js","sourceRoot":"","sources":["../../../../projects/siarashield-workspace/src/lib/siara-shield.ts"],"names":[],"mappings":"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","sourcesContent":["import { getInitCaptchaFn, getSiaraShieldGlobals } from './siara-shield.globals';\nimport { installVendorRuntimeErrorSuppression, suppressVendorConsoleWindow } from './siara-shield-log-utils';\nimport { loadScript, prepareScriptNonce } from './siara-shield-script-utils';\nimport { installCaptchaSubmitGuard } from './siara-shield-submit-guard';\n\nconst JQUERY_FALLBACK_SRC = 'https://embedcdn.mycybersiara.com/capcha-temple/js/jquery.min.js';\nconst CAPTCHA_SCRIPT_SRC = 'https://embedcdn.mycybersiara.com/CaptchaFormate/CaptchaResources.js';\nconst VALIDATION_SCRIPT_SRC = 'https://embed.mycybersiara.com/CaptchaFormate/SiaraShield_Validation.js';\nconst CAPTCHA_READY_TIMEOUT_MS = 8000;\n\nexport interface InitSiaraShieldOptions {\n  /** SiaraShield public key. Use \"TEST-CYBERSIARA\" for staging/development. */\n  publicKey: string;\n  /**\n   * Loads jQuery before SiaraShield script.\n   * Default is true for easier integration.\n   * Set to false only if your site/app already loads jQuery.\n   */\n  loadJQuery?: boolean;\n  /** CSP nonce for strict policies (`script-src 'nonce-...'`). Pair with `getSiaraShieldCspPolicy()`. */\n  cspNonce?: string;\n  /** Set true only when actively debugging vendor/runtime internals in browser console. */\n  allowVendorConsoleLogs?: boolean;\n}\n\nlet pending: Promise<void> | null = null;\nlet initialized = false;\n\nfunction ensureAccessibilityPopupAliases(): void {\n  const g = globalThis as typeof globalThis & Record<string, unknown>;\n  const aliasNames = [\n    'RemoveAccesibilityPopup',\n    '_RemoveAccesibilityPopup',\n    'RemoveAccesiblityPopup',\n    '_RemoveAccesiblityPopup',\n  ] as const;\n\n  const existing = aliasNames\n    .map((name) => g[name])\n    .find((value): value is () => void => typeof value === 'function');\n\n  const stableFn = existing ?? (() => undefined);\n  for (const name of aliasNames) {\n    g[name] = stableFn;\n  }\n}\n\nfunction isJQueryAlreadyAvailable(): boolean {\n  const g = getSiaraShieldGlobals();\n  if (typeof g.jQuery === 'function' || typeof g.$ === 'function') {\n    return true;\n  }\n\n  const existingJqueryScript = document.querySelector<HTMLScriptElement>('script[src*=\"jquery\"]');\n  return Boolean(existingJqueryScript);\n}\n\nfunction runInRootZone<T>(fn: () => T): T {\n  const g = globalThis as typeof globalThis & { Zone?: { root?: { run?: <U>(cb: () => U) => U } } };\n  const zoneRootRun = g.Zone?.root?.run;\n  if (typeof zoneRootRun === 'function') {\n    return zoneRootRun.call(g.Zone?.root, fn) as T;\n  }\n  return fn();\n}\n\nfunction preventDuplicateValidationBootstrap(g: ReturnType<typeof getSiaraShieldGlobals>): void {\n  const originalAppendValidation = g.AppendValidationJS;\n  if (typeof originalAppendValidation !== 'function') {\n    return;\n  }\n\n  g.AppendValidationJS = () => {\n    const existing = document.querySelector<HTMLScriptElement>(`script[src=\"${VALIDATION_SCRIPT_SRC}\"]`);\n    if (existing) {\n      return;\n    }\n\n    originalAppendValidation();\n  };\n}\n\nasync function waitForCheckCaptchaApi(timeoutMs = CAPTCHA_READY_TIMEOUT_MS): Promise<void> {\n  const startedAt = Date.now();\n  while (Date.now() - startedAt < timeoutMs) {\n    if (getSiaraShieldGlobals().CheckCaptcha) {\n      return;\n    }\n    await new Promise((resolve) => setTimeout(resolve, 100));\n  }\n  throw new Error('SiaraShield: CheckCaptcha() was not available within timeout. This can happen when CSP blocks the captcha runtime.');\n}\n\n/**\n * Drop-in initializer for SiaraShield.\n * - Loads required scripts (optionally jQuery)\n * - Calls global `initCaptcha(publicKey)`\n *\n * Requirements in your HTML/template:\n * - You must render: `<div class=\"SiaraShield\"></div>`\n */\nexport async function initSiaraShield(options: InitSiaraShieldOptions): Promise<void> {\n  if (initialized) return;\n  if (pending) return pending;\n\n  if (!options?.publicKey) {\n    throw new Error('initSiaraShield: publicKey is required.');\n  }\n\n  pending = (async () => {\n    installCaptchaSubmitGuard();\n    const cspNonce = prepareScriptNonce(document, options.cspNonce);\n\n    if ((options.loadJQuery ?? true) && !isJQueryAlreadyAvailable()) {\n      await loadScript(document, JQUERY_FALLBACK_SRC, { nonce: cspNonce });\n    }\n\n    await loadScript(document, CAPTCHA_SCRIPT_SRC, {\n      nonce: cspNonce,\n    });\n    await loadScript(document, VALIDATION_SCRIPT_SRC, {\n      nonce: cspNonce,\n    });\n\n    const g = getSiaraShieldGlobals();\n    ensureAccessibilityPopupAliases();\n    preventDuplicateValidationBootstrap(g);\n    const initCaptchaFn = getInitCaptchaFn(g);\n    if (!initCaptchaFn) {\n      throw new Error(\n        'SiaraShield: InitCaptcha() is not available after loading scripts. Check whether CSP blocked vendor scripts or inline execution.',\n      );\n    }\n\n    if (!options.allowVendorConsoleLogs) {\n      suppressVendorConsoleWindow();\n      installVendorRuntimeErrorSuppression();\n    }\n    runInRootZone(() => initCaptchaFn(options.publicKey));\n    await waitForCheckCaptchaApi();\n    initialized = true;\n  })();\n\n  try {\n    await pending;\n  } finally {\n    // keep `pending` cached for subsequent callers\n  }\n}\n\n/**\n * Calls global `CheckCaptcha()` and returns its boolean result.\n * If successful, returns `{ ok: true, token?: string }`.\n */\nexport function checkSiaraShieldCaptcha(options?: { allowVendorConsoleLogs?: boolean }): { ok: boolean; token?: string } {\n  const g = getSiaraShieldGlobals();\n  if (!g.CheckCaptcha) {\n    throw new Error('SiaraShield: CheckCaptcha() is not available. Did initSiaraShield() run, and is CSP allowing the captcha scripts?');\n  }\n\n  if (!options?.allowVendorConsoleLogs) {\n    suppressVendorConsoleWindow();\n  }\n  const ok = g.CheckCaptcha();\n  const token = typeof g.CyberSiaraToken === 'string' ? g.CyberSiaraToken : undefined;\n  return ok ? { ok: true, token } : { ok: false };\n}\n\n/**\n * Async-friendly captcha check to handle delayed token population.\n */\nexport async function checkSiaraShieldCaptchaAsync(options?: {\n  timeoutMs?: number;\n  pollIntervalMs?: number;\n  beforeCheckDelayMs?: number;\n}): Promise<{ ok: boolean; token?: string }> {\n  const timeoutMs = options?.timeoutMs ?? 1200;\n  const pollIntervalMs = options?.pollIntervalMs ?? 120;\n  const beforeCheckDelayMs = options?.beforeCheckDelayMs ?? 140;\n  await new Promise((resolve) => setTimeout(resolve, beforeCheckDelayMs));\n  const firstCheck = checkSiaraShieldCaptcha(); // one API call only\n  if (!firstCheck.ok) return firstCheck;\n  if (firstCheck.token) return firstCheck;\n\n  const startedAt = Date.now();\n  // Token can be assigned slightly after successful verification.\n  while (Date.now() - startedAt < timeoutMs) {\n    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));\n    const token = getSiaraShieldGlobals().CyberSiaraToken;\n    if (typeof token === 'string' && token.length > 0) {\n      return { ok: true, token };\n    }\n  }\n\n  return { ok: true };\n}\n\n"]}

package/esm2022/lib/siarashield-workspace.mjs

@@ -0,0 +1,4 @@
+export { SiaraShieldComponent } from './siara-shield.component';
+export { SiaraShieldLoaderService } from './siara-shield-loader.service';
+export { getSiaraShieldGlobals } from './siara-shield.globals';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lhcmFzaGllbGQtd29ya3NwYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvc2lhcmFzaGllbGQtd29ya3NwYWNlL3NyYy9saWIvc2lhcmFzaGllbGQtd29ya3NwYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ2hFLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3pFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgU2lhcmFTaGllbGRDb21wb25lbnQgfSBmcm9tICcuL3NpYXJhLXNoaWVsZC5jb21wb25lbnQnO1xuZXhwb3J0IHsgU2lhcmFTaGllbGRMb2FkZXJTZXJ2aWNlIH0gZnJvbSAnLi9zaWFyYS1zaGllbGQtbG9hZGVyLnNlcnZpY2UnO1xuZXhwb3J0IHsgZ2V0U2lhcmFTaGllbGRHbG9iYWxzIH0gZnJvbSAnLi9zaWFyYS1zaGllbGQuZ2xvYmFscyc7XG4iXX0=

package/esm2022/public-api.mjs

@@ -0,0 +1,10 @@
+/*
+ * Public API Surface of siarashield-workspace
+ */
+export * from './lib/siarashield-workspace';
+export * from './lib/siara-shield.component';
+export * from './lib/siara-shield-loader.service';
+export * from './lib/siara-shield.globals';
+export * from './lib/siara-shield';
+export * from './lib/siara-shield-csp';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NpYXJhc2hpZWxkLXdvcmtzcGFjZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHdCQUF3QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzaWFyYXNoaWVsZC13b3Jrc3BhY2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaWFyYXNoaWVsZC13b3Jrc3BhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2lhcmEtc2hpZWxkLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaWFyYS1zaGllbGQtbG9hZGVyLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2lhcmEtc2hpZWxkLmdsb2JhbHMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2lhcmEtc2hpZWxkJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NpYXJhLXNoaWVsZC1jc3AnO1xuIl19

package/esm2022/siarashield_workspace.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lhcmFzaGllbGRfd29ya3NwYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvc2lhcmFzaGllbGQtd29ya3NwYWNlL3NyYy9zaWFyYXNoaWVsZF93b3Jrc3BhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/fesm2022/siarashield_workspace.mjs

@@ -83,8 +83,12 @@ function isLikelyVendorScriptRuntimeError(message, source) {
     const normalizedMessage = String(message ?? '').trim().toLowerCase();
     const normalizedSource = String(source ?? '').trim().toLowerCase();
     const fromSiaraHost = normalizedSource.includes('embed.mycybersiara.com') || normalizedSource.includes('embedcdn.mycybersiara.com');
+    const isKnownVendorDomError = normalizedMessage.includes("cannot read properties of null (reading 'removechild')") &&
+        (normalizedSource.includes('jquery') || normalizedSource.includes('captcharesources'));
     if (fromSiaraHost)
         return true;
+    if (isKnownVendorDomError)
+        return true;
     return normalizedMessage === 'script error.' || normalizedMessage === 'script error';
 }
 /**
@@ -282,8 +286,9 @@ function resolveCspNonce(documentRef, explicitNonce) {
 function prepareScriptNonce(documentRef, explicitNonce) {
     const resolvedNonce = resolveCspNonce(documentRef, explicitNonce);
     const patchState = getDynamicScriptNoncePatchState();
-    patchDynamicScriptInsertion();
     if (resolvedNonce) {
+        // DOM patching is only needed when a CSP nonce must be propagated.
+        patchDynamicScriptInsertion();
         patchState.nonceByDocument.set(documentRef, resolvedNonce);
         ensureNonceMutationObserver(documentRef);
     }
@@ -333,12 +338,12 @@ function loadScript(documentRef, src, options) {
 }
 
 const SUBMIT_GUARD_STATE_KEY = '__siaraShieldSubmitGuardInstalled__';
-const TRUSTED_CLICK_GUARD_WINDOW_MS = 1000;
+const SYNTHETIC_CLICK_GUARD_WINDOW_MS = 1200;
 function installCaptchaSubmitGuard() {
     const globalState = globalThis;
     if (globalState[SUBMIT_GUARD_STATE_KEY])
         return;
-    const lastTrustedClickByButton = new WeakMap();
+    const lastSyntheticClickByButton = new WeakMap();
     document.addEventListener('click', (event) => {
         const target = event.target;
         if (!(target instanceof Element))
@@ -347,20 +352,17 @@ function installCaptchaSubmitGuard() {
         if (!submitButton)
             return;
         // Vendor runtime can emit synthetic clicks on .CaptchaSubmit.
-        // Always block synthetic clicks so a real user click maps to one app handler call.
+        // Allow one synthetic click (needed for vendor auto-submit) but block rapid duplicates.
         if (!event.isTrusted) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            return;
-        }
-        const now = Date.now();
-        const lastTrustedClickAt = lastTrustedClickByButton.get(submitButton) ?? 0;
-        if (now - lastTrustedClickAt < TRUSTED_CLICK_GUARD_WINDOW_MS) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            return;
+            const now = Date.now();
+            const lastSyntheticClickAt = lastSyntheticClickByButton.get(submitButton) ?? 0;
+            if (now - lastSyntheticClickAt < SYNTHETIC_CLICK_GUARD_WINDOW_MS) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+                return;
+            }
+            lastSyntheticClickByButton.set(submitButton, now);
         }
-        lastTrustedClickByButton.set(submitButton, now);
     }, true);
     globalState[SUBMIT_GUARD_STATE_KEY] = true;
 }
@@ -373,10 +375,10 @@ class SiaraShieldLoaderService {
     loadScript(src, options) {
         return loadScript(this.document, src, options);
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: SiaraShieldLoaderService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: SiaraShieldLoaderService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldLoaderService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldLoaderService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: SiaraShieldLoaderService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldLoaderService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: Document, decorators: [{
@@ -408,7 +410,7 @@ function runInRootZone$1(fn) {
     const g = globalThis;
     const zoneRootRun = g.Zone?.root?.run;
     if (typeof zoneRootRun === 'function') {
-        return zoneRootRun(fn);
+        return zoneRootRun.call(g.Zone?.root, fn);
     }
     return fn();
 }
@@ -549,10 +551,10 @@ class SiaraShieldComponent {
         }
         return true;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: SiaraShieldComponent, deps: [{ token: i0.ElementRef }, { token: SiaraShieldLoaderService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "21.2.5", type: SiaraShieldComponent, isStandalone: true, selector: "siara-shield", inputs: { publicKey: "publicKey", loadJQuery: "loadJQuery", cspNonce: "cspNonce", allowVendorConsoleLogs: "allowVendorConsoleLogs" }, outputs: { token: "token" }, ngImport: i0, template: `<div class="SiaraShield"></div>`, isInline: true, encapsulation: i0.ViewEncapsulation.None });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldComponent, deps: [{ token: i0.ElementRef }, { token: SiaraShieldLoaderService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: SiaraShieldComponent, isStandalone: true, selector: "siara-shield", inputs: { publicKey: "publicKey", loadJQuery: "loadJQuery", cspNonce: "cspNonce", allowVendorConsoleLogs: "allowVendorConsoleLogs" }, outputs: { token: "token" }, ngImport: i0, template: `<div class="SiaraShield"></div>`, isInline: true, encapsulation: i0.ViewEncapsulation.None });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.5", ngImport: i0, type: SiaraShieldComponent, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: SiaraShieldComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'siara-shield',
@@ -607,7 +609,7 @@ function runInRootZone(fn) {
     const g = globalThis;
     const zoneRootRun = g.Zone?.root?.run;
     if (typeof zoneRootRun === 'function') {
-        return zoneRootRun(fn);
+        return zoneRootRun.call(g.Zone?.root, fn);
     }
     return fn();
 }