siarashield_workspace 0.0.30 → 0.0.32

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

@@ -0,0 +1,80 @@
+const SELF = "'self'";
+const DATA = 'data:';
+const UNSAFE_INLINE = "'unsafe-inline'";
+const SCRIPT_HOSTS = ['https://embedcdn.mycybersiara.com', 'https://embed.mycybersiara.com'];
+const OPTIONAL_SCRIPT_HOSTS = ['https://ajax.googleapis.com'];
+const CONNECT_HOSTS = ['https://embed.mycybersiara.com', 'https://embedcdn.mycybersiara.com'];
+const STYLE_HOSTS = [
+    'https://embed.mycybersiara.com',
+    'https://mycybersiara.com',
+    'https://fonts.googleapis.com',
+    'https://cdnjs.cloudflare.com',
+];
+const FONT_HOSTS = [
+    'https://fonts.gstatic.com',
+    'https://mycybersiara.com',
+    'https://cdnjs.cloudflare.com',
+];
+const IMG_HOSTS = [
+    'https://embed.mycybersiara.com',
+    'https://embedcdn.mycybersiara.com',
+    'https://mycybersiara.com',
+];
+function unique(values) {
+    return [...new Set(values.filter((value) => Boolean(value && value.trim())))];
+}
+function nonceSource(nonce) {
+    return nonce ? `'nonce-${nonce}'` : undefined;
+}
+function serializeDirective(name, values) {
+    return values.length > 0 ? `${name} ${values.join(' ')}` : name;
+}
+function parsePolicy(policy) {
+    const directives = new Map();
+    for (const rawDirective of policy.split(';')) {
+        const directive = rawDirective.trim();
+        if (!directive) {
+            continue;
+        }
+        const parts = directive.split(/\s+/).filter(Boolean);
+        const [name, ...values] = parts;
+        if (!name) {
+            continue;
+        }
+        directives.set(name, values);
+    }
+    return directives;
+}
+export function getSiaraShieldCspDirectives(options) {
+    const includeGoogleApis = options?.includeGoogleApis ?? false;
+    // Default to strict/safe CSP. Customers can explicitly opt-in if they accept the risk.
+    const includeUnsafeInlineScript = options?.includeUnsafeInlineScript ?? false;
+    const includeUnsafeInlineStyle = options?.includeUnsafeInlineStyle ?? false;
+    const nonce = nonceSource(options?.nonce);
+    const scriptHosts = includeGoogleApis ? [...SCRIPT_HOSTS, ...OPTIONAL_SCRIPT_HOSTS] : [...SCRIPT_HOSTS];
+    return {
+        'default-src': unique([SELF]),
+        'script-src': unique([SELF, nonce, ...scriptHosts, includeUnsafeInlineScript ? UNSAFE_INLINE : undefined]),
+        'script-src-elem': unique([SELF, nonce, ...scriptHosts]),
+        'connect-src': unique([SELF, ...CONNECT_HOSTS]),
+        'img-src': unique([SELF, DATA, ...IMG_HOSTS]),
+        'style-src': unique([SELF, includeUnsafeInlineStyle ? UNSAFE_INLINE : undefined, ...STYLE_HOSTS]),
+        'font-src': unique([SELF, ...FONT_HOSTS, DATA]),
+    };
+}
+export function getSiaraShieldCspPolicy(options) {
+    return Object.entries(getSiaraShieldCspDirectives(options))
+        .map(([name, values]) => serializeDirective(name, values))
+        .join('; ');
+}
+export function mergeSiaraShieldCspPolicy(existingPolicy, options) {
+    const directives = parsePolicy(existingPolicy);
+    const recommended = getSiaraShieldCspDirectives(options);
+    for (const [name, values] of Object.entries(recommended)) {
+        directives.set(name, unique([...(directives.get(name) ?? []), ...values]));
+    }
+    return [...directives.entries()]
+        .map(([name, values]) => serializeDirective(name, values))
+        .join('; ');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"siara-shield-csp.js","sourceRoot":"","sources":["../../../../projects/siarashield-workspace/src/lib/siara-shield-csp.ts"],"names":[],"mappings":"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","sourcesContent":["export interface SiaraShieldCspOptions {\n  /** Server-generated nonce value without the `'nonce-'` prefix. */\n  nonce?: string;\n  /** Optional if the customer still loads jQuery from Google's CDN. */\n  includeGoogleApis?: boolean;\n  /** Include `script-src 'unsafe-inline'` (not recommended for production). */\n  includeUnsafeInlineScript?: boolean;\n  /** Include `style-src 'unsafe-inline'` (not recommended for production). */\n  includeUnsafeInlineStyle?: boolean;\n}\n\nexport type SiaraShieldCspDirectives = Record<string, string[]>;\n\nconst SELF = \"'self'\";\nconst DATA = 'data:';\nconst UNSAFE_INLINE = \"'unsafe-inline'\";\n\nconst SCRIPT_HOSTS = ['https://embedcdn.mycybersiara.com', 'https://embed.mycybersiara.com'] as const;\nconst OPTIONAL_SCRIPT_HOSTS = ['https://ajax.googleapis.com'] as const;\nconst CONNECT_HOSTS = ['https://embed.mycybersiara.com', 'https://embedcdn.mycybersiara.com'] as const;\nconst STYLE_HOSTS = [\n  'https://embed.mycybersiara.com',\n  'https://mycybersiara.com',\n  'https://fonts.googleapis.com',\n  'https://cdnjs.cloudflare.com',\n] as const;\nconst FONT_HOSTS = [\n  'https://fonts.gstatic.com',\n  'https://mycybersiara.com',\n  'https://cdnjs.cloudflare.com',\n] as const;\nconst IMG_HOSTS = [\n  'https://embed.mycybersiara.com',\n  'https://embedcdn.mycybersiara.com',\n  'https://mycybersiara.com',\n] as const;\n\nfunction unique(values: Array<string | undefined>): string[] {\n  return [...new Set(values.filter((value): value is string => Boolean(value && value.trim())))];\n}\n\nfunction nonceSource(nonce?: string): string | undefined {\n  return nonce ? `'nonce-${nonce}'` : undefined;\n}\n\nfunction serializeDirective(name: string, values: string[]): string {\n  return values.length > 0 ? `${name} ${values.join(' ')}` : name;\n}\n\nfunction parsePolicy(policy: string): Map<string, string[]> {\n  const directives = new Map<string, string[]>();\n\n  for (const rawDirective of policy.split(';')) {\n    const directive = rawDirective.trim();\n    if (!directive) {\n      continue;\n    }\n\n    const parts = directive.split(/\\s+/).filter(Boolean);\n    const [name, ...values] = parts;\n    if (!name) {\n      continue;\n    }\n\n    directives.set(name, values);\n  }\n\n  return directives;\n}\n\nexport function getSiaraShieldCspDirectives(options?: SiaraShieldCspOptions): SiaraShieldCspDirectives {\n  const includeGoogleApis = options?.includeGoogleApis ?? false;\n  // Default to strict/safe CSP. Customers can explicitly opt-in if they accept the risk.\n  const includeUnsafeInlineScript = options?.includeUnsafeInlineScript ?? false;\n  const includeUnsafeInlineStyle = options?.includeUnsafeInlineStyle ?? false;\n  const nonce = nonceSource(options?.nonce);\n  const scriptHosts = includeGoogleApis ? [...SCRIPT_HOSTS, ...OPTIONAL_SCRIPT_HOSTS] : [...SCRIPT_HOSTS];\n\n  return {\n    'default-src': unique([SELF]),\n    'script-src': unique([SELF, nonce, ...scriptHosts, includeUnsafeInlineScript ? UNSAFE_INLINE : undefined]),\n    'script-src-elem': unique([SELF, nonce, ...scriptHosts]),\n    'connect-src': unique([SELF, ...CONNECT_HOSTS]),\n    'img-src': unique([SELF, DATA, ...IMG_HOSTS]),\n    'style-src': unique([SELF, includeUnsafeInlineStyle ? UNSAFE_INLINE : undefined, ...STYLE_HOSTS]),\n    'font-src': unique([SELF, ...FONT_HOSTS, DATA]),\n  };\n}\n\nexport function getSiaraShieldCspPolicy(options?: SiaraShieldCspOptions): string {\n  return Object.entries(getSiaraShieldCspDirectives(options))\n    .map(([name, values]) => serializeDirective(name, values))\n    .join('; ');\n}\n\nexport function mergeSiaraShieldCspPolicy(existingPolicy: string, options?: SiaraShieldCspOptions): string {\n  const directives = parsePolicy(existingPolicy);\n  const recommended = getSiaraShieldCspDirectives(options);\n\n  for (const [name, values] of Object.entries(recommended)) {\n    directives.set(name, unique([...(directives.get(name) ?? []), ...values]));\n  }\n\n  return [...directives.entries()]\n    .map(([name, values]) => serializeDirective(name, values))\n    .join('; ');\n}\n"]}

package/esm2022/lib/siara-shield-loader.service.mjs

@@ -0,0 +1,23 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { loadScript } from './siara-shield-script-utils';
+import * as i0 from "@angular/core";
+export class SiaraShieldLoaderService {
+    document;
+    constructor(document) {
+        this.document = document;
+    }
+    loadScript(src, options) {
+        return loadScript(this.document, src, options);
+    }
+    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: "17.3.12", ngImport: i0, type: SiaraShieldLoaderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lhcmEtc2hpZWxkLWxvYWRlci5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvc2lhcmFzaGllbGQtd29ya3NwYWNlL3NyYy9saWIvc2lhcmEtc2hpZWxkLWxvYWRlci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMzQyxPQUFPLEVBQUUsTUFBTSxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVuRCxPQUFPLEVBQUUsVUFBVSxFQUEwQixNQUFNLDZCQUE2QixDQUFDOztBQUdqRixNQUFNLE9BQU8sd0JBQXdCO0lBQ1k7SUFBL0MsWUFBK0MsUUFBa0I7UUFBbEIsYUFBUSxHQUFSLFFBQVEsQ0FBVTtJQUFHLENBQUM7SUFFckUsVUFBVSxDQUFDLEdBQVcsRUFBRSxPQUEyQjtRQUNqRCxPQUFPLFVBQVUsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEdBQUcsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUNqRCxDQUFDO3dHQUxVLHdCQUF3QixrQkFDZixRQUFROzRHQURqQix3QkFBd0IsY0FEWCxNQUFNOzs0RkFDbkIsd0JBQXdCO2tCQURwQyxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRTs7MEJBRW5CLE1BQU07MkJBQUMsUUFBUSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERPQ1VNRU5UIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5pbXBvcnQgeyBsb2FkU2NyaXB0LCB0eXBlIFNjcmlwdExvYWRPcHRpb25zIH0gZnJvbSAnLi9zaWFyYS1zaGllbGQtc2NyaXB0LXV0aWxzJztcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBTaWFyYVNoaWVsZExvYWRlclNlcnZpY2Uge1xuICBjb25zdHJ1Y3RvcihASW5qZWN0KERPQ1VNRU5UKSBwcml2YXRlIHJlYWRvbmx5IGRvY3VtZW50OiBEb2N1bWVudCkge31cblxuICBsb2FkU2NyaXB0KHNyYzogc3RyaW5nLCBvcHRpb25zPzogU2NyaXB0TG9hZE9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICByZXR1cm4gbG9hZFNjcmlwdCh0aGlzLmRvY3VtZW50LCBzcmMsIG9wdGlvbnMpO1xuICB9XG59XG4iXX0=

package/esm2022/lib/siara-shield-log-utils.mjs

@@ -0,0 +1,103 @@
+const CONSOLE_PATCH_STATE_KEY = '__siaraShieldConsolePatchState__';
+const VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY = '__siaraShieldVendorRuntimeErrorPatchState__';
+const DEFAULT_SUPPRESS_WINDOW_MS = 2000;
+function getConsolePatchState() {
+    const globalState = globalThis;
+    if (!globalState[CONSOLE_PATCH_STATE_KEY]) {
+        globalState[CONSOLE_PATCH_STATE_KEY] = {
+            depth: 0,
+            originalLog: console.log.bind(console),
+            originalInfo: console.info.bind(console),
+            originalWarn: console.warn.bind(console),
+            originalDebug: console.debug.bind(console),
+            originalError: console.error.bind(console),
+        };
+    }
+    return globalState[CONSOLE_PATCH_STATE_KEY];
+}
+function muteConsole() {
+    const patchState = getConsolePatchState();
+    patchState.depth += 1;
+    if (patchState.depth > 1)
+        return;
+    console.log = () => undefined;
+    console.info = () => undefined;
+    console.warn = () => undefined;
+    console.debug = () => undefined;
+    console.error = (...args) => {
+        const normalized = args
+            .map((arg) => (typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : ''))
+            .join(' ')
+            .toLowerCase();
+        // Known noisy upstream vendor runtime error path from CaptchaResources.js bootstrap.
+        if (normalized.includes('an errorevent with no error occurred') ||
+            normalized.includes('script error') ||
+            normalized.includes('captcharesources.js') ||
+            normalized.includes('getcybersiara')) {
+            return;
+        }
+        patchState.originalError(...args);
+    };
+}
+function unmuteConsole() {
+    const patchState = getConsolePatchState();
+    if (patchState.depth === 0)
+        return;
+    patchState.depth -= 1;
+    if (patchState.depth > 0)
+        return;
+    console.log = patchState.originalLog;
+    console.info = patchState.originalInfo;
+    console.warn = patchState.originalWarn;
+    console.debug = patchState.originalDebug;
+    console.error = patchState.originalError;
+}
+export function suppressVendorConsoleWindow(windowMs = DEFAULT_SUPPRESS_WINDOW_MS) {
+    muteConsole();
+    setTimeout(() => {
+        unmuteConsole();
+    }, windowMs);
+}
+function getVendorRuntimeErrorPatchState() {
+    const globalState = globalThis;
+    if (!globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY]) {
+        globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY] = {
+            installed: false,
+            originalOnError: globalThis.onerror ?? null,
+        };
+    }
+    return globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY];
+}
+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';
+}
+/**
+ * Suppresses noisy cross-origin vendor runtime script errors so Angular does not
+ * surface them as unhandled `ErrorEvent` crashes in the console.
+ */
+export function installVendorRuntimeErrorSuppression() {
+    const patchState = getVendorRuntimeErrorPatchState();
+    if (patchState.installed)
+        return;
+    const previousOnError = patchState.originalOnError;
+    globalThis.onerror = (message, source, lineno, colno, error) => {
+        if (isLikelyVendorScriptRuntimeError(message, source)) {
+            return true;
+        }
+        if (typeof previousOnError === 'function') {
+            return previousOnError.call(globalThis, message, source, lineno, colno, error);
+        }
+        return false;
+    };
+    patchState.installed = true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"siara-shield-log-utils.js","sourceRoot":"","sources":["../../../../projects/siarashield-workspace/src/lib/siara-shield-log-utils.ts"],"names":[],"mappings":"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","sourcesContent":["interface ConsolePatchState {\n  depth: number;\n  originalLog: Console['log'];\n  originalInfo: Console['info'];\n  originalWarn: Console['warn'];\n  originalDebug: Console['debug'];\n  originalError: Console['error'];\n}\n\ninterface VendorRuntimeErrorPatchState {\n  installed: boolean;\n  originalOnError: OnErrorEventHandler | null;\n}\n\nconst CONSOLE_PATCH_STATE_KEY = '__siaraShieldConsolePatchState__';\nconst VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY = '__siaraShieldVendorRuntimeErrorPatchState__';\nconst DEFAULT_SUPPRESS_WINDOW_MS = 2000;\n\nfunction getConsolePatchState(): ConsolePatchState {\n  const globalState = globalThis as typeof globalThis & {\n    [CONSOLE_PATCH_STATE_KEY]?: ConsolePatchState;\n  };\n\n  if (!globalState[CONSOLE_PATCH_STATE_KEY]) {\n    globalState[CONSOLE_PATCH_STATE_KEY] = {\n      depth: 0,\n      originalLog: console.log.bind(console),\n      originalInfo: console.info.bind(console),\n      originalWarn: console.warn.bind(console),\n      originalDebug: console.debug.bind(console),\n      originalError: console.error.bind(console),\n    };\n  }\n\n  return globalState[CONSOLE_PATCH_STATE_KEY];\n}\n\nfunction muteConsole(): void {\n  const patchState = getConsolePatchState();\n  patchState.depth += 1;\n  if (patchState.depth > 1) return;\n\n  console.log = () => undefined;\n  console.info = () => undefined;\n  console.warn = () => undefined;\n  console.debug = () => undefined;\n  console.error = (...args: unknown[]) => {\n    const normalized = args\n      .map((arg) => (typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : ''))\n      .join(' ')\n      .toLowerCase();\n\n    // Known noisy upstream vendor runtime error path from CaptchaResources.js bootstrap.\n    if (\n      normalized.includes('an errorevent with no error occurred') ||\n      normalized.includes('script error') ||\n      normalized.includes('captcharesources.js') ||\n      normalized.includes('getcybersiara')\n    ) {\n      return;\n    }\n\n    patchState.originalError(...args);\n  };\n}\n\nfunction unmuteConsole(): void {\n  const patchState = getConsolePatchState();\n  if (patchState.depth === 0) return;\n  patchState.depth -= 1;\n  if (patchState.depth > 0) return;\n\n  console.log = patchState.originalLog;\n  console.info = patchState.originalInfo;\n  console.warn = patchState.originalWarn;\n  console.debug = patchState.originalDebug;\n  console.error = patchState.originalError;\n}\n\nexport function suppressVendorConsoleWindow(windowMs = DEFAULT_SUPPRESS_WINDOW_MS): void {\n  muteConsole();\n  setTimeout(() => {\n    unmuteConsole();\n  }, windowMs);\n}\n\nfunction getVendorRuntimeErrorPatchState(): VendorRuntimeErrorPatchState {\n  const globalState = globalThis as typeof globalThis & {\n    [VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY]?: VendorRuntimeErrorPatchState;\n  };\n\n  if (!globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY]) {\n    globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY] = {\n      installed: false,\n      originalOnError: globalThis.onerror ?? null,\n    };\n  }\n\n  return globalState[VENDOR_RUNTIME_ERROR_PATCH_STATE_KEY];\n}\n\nfunction isLikelyVendorScriptRuntimeError(message: unknown, source: unknown): boolean {\n  const normalizedMessage = String(message ?? '').trim().toLowerCase();\n  const normalizedSource = String(source ?? '').trim().toLowerCase();\n  const fromSiaraHost =\n    normalizedSource.includes('embed.mycybersiara.com') || normalizedSource.includes('embedcdn.mycybersiara.com');\n  const isKnownVendorDomError =\n    normalizedMessage.includes(\"cannot read properties of null (reading 'removechild')\") &&\n    (normalizedSource.includes('jquery') || normalizedSource.includes('captcharesources'));\n\n  if (fromSiaraHost) return true;\n  if (isKnownVendorDomError) return true;\n  return normalizedMessage === 'script error.' || normalizedMessage === 'script error';\n}\n\n/**\n * Suppresses noisy cross-origin vendor runtime script errors so Angular does not\n * surface them as unhandled `ErrorEvent` crashes in the console.\n */\nexport function installVendorRuntimeErrorSuppression(): void {\n  const patchState = getVendorRuntimeErrorPatchState();\n  if (patchState.installed) return;\n\n  const previousOnError = patchState.originalOnError;\n  globalThis.onerror = (message, source, lineno, colno, error) => {\n    if (isLikelyVendorScriptRuntimeError(message, source)) {\n      return true;\n    }\n\n    if (typeof previousOnError === 'function') {\n      return previousOnError.call(globalThis, message, source, lineno, colno, error);\n    }\n\n    return false;\n  };\n\n  patchState.installed = true;\n}\n\n"]}

package/esm2022/lib/siara-shield-script-utils.mjs

@@ -0,0 +1,225 @@
+const SCRIPT_STATUS_BY_DOCUMENT = new WeakMap();
+const SCRIPT_PENDING_BY_DOCUMENT = new WeakMap();
+const DYNAMIC_SCRIPT_NONCE_STATE_KEY = '__siaraShieldDynamicScriptNonceState__';
+function getStatusBySrc(documentRef) {
+    let statusBySrc = SCRIPT_STATUS_BY_DOCUMENT.get(documentRef);
+    if (!statusBySrc) {
+        statusBySrc = new Map();
+        SCRIPT_STATUS_BY_DOCUMENT.set(documentRef, statusBySrc);
+    }
+    return statusBySrc;
+}
+function getPendingBySrc(documentRef) {
+    let pendingBySrc = SCRIPT_PENDING_BY_DOCUMENT.get(documentRef);
+    if (!pendingBySrc) {
+        pendingBySrc = new Map();
+        SCRIPT_PENDING_BY_DOCUMENT.set(documentRef, pendingBySrc);
+    }
+    return pendingBySrc;
+}
+function getDynamicScriptNoncePatchState() {
+    const globalState = globalThis;
+    if (!globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY]) {
+        globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY] = {
+            nonceByDocument: new WeakMap(),
+            observerByDocument: new WeakMap(),
+            inlineCaptchaScriptByDocument: new WeakMap(),
+            patched: false,
+        };
+    }
+    return globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY];
+}
+function normalizeNonce(nonce) {
+    const trimmed = nonce?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function isScriptElement(node) {
+    return node instanceof Element && node.tagName.toLowerCase() === 'script';
+}
+export function applyScriptNonce(script, nonce) {
+    const resolvedNonce = normalizeNonce(nonce);
+    if (!resolvedNonce) {
+        return;
+    }
+    script.setAttribute('nonce', resolvedNonce);
+    script.nonce = resolvedNonce;
+}
+function applyTrackedNonce(node) {
+    if (!isScriptElement(node)) {
+        return;
+    }
+    const documentRef = node.ownerDocument;
+    if (!documentRef) {
+        return;
+    }
+    const nonce = getDynamicScriptNoncePatchState().nonceByDocument.get(documentRef);
+    applyScriptNonce(node, nonce);
+}
+function getTrackedInlineCaptchaScripts(documentRef) {
+    const patchState = getDynamicScriptNoncePatchState();
+    let trackedScripts = patchState.inlineCaptchaScriptByDocument.get(documentRef);
+    if (!trackedScripts) {
+        trackedScripts = new Set();
+        patchState.inlineCaptchaScriptByDocument.set(documentRef, trackedScripts);
+    }
+    return trackedScripts;
+}
+function shouldSkipDuplicateInlineCaptchaScript(node) {
+    if (!isScriptElement(node) || Boolean(node.src)) {
+        return false;
+    }
+    const scriptBody = (node.textContent ?? '').trim();
+    if (!scriptBody || !scriptBody.includes('currentLangCode')) {
+        return false;
+    }
+    const documentRef = node.ownerDocument;
+    if (!documentRef) {
+        return false;
+    }
+    const trackedScripts = getTrackedInlineCaptchaScripts(documentRef);
+    if (trackedScripts.has(scriptBody)) {
+        return true;
+    }
+    trackedScripts.add(scriptBody);
+    return false;
+}
+function walkAndApplyNonce(root, nonce) {
+    if (!nonce)
+        return;
+    // Fast path: root itself is a script.
+    if (isScriptElement(root)) {
+        applyScriptNonce(root, nonce);
+        return;
+    }
+    // Common path for jQuery: append DocumentFragment containing scripts created via HTML parsing.
+    if (root instanceof Element || root instanceof DocumentFragment) {
+        const scripts = root.querySelectorAll?.('script') ?? [];
+        for (const script of scripts) {
+            applyScriptNonce(script, nonce);
+        }
+    }
+}
+function ensureNonceMutationObserver(documentRef) {
+    const patchState = getDynamicScriptNoncePatchState();
+    if (patchState.observerByDocument.get(documentRef)) {
+        return;
+    }
+    const observer = new MutationObserver((records) => {
+        const nonce = patchState.nonceByDocument.get(documentRef);
+        if (!nonce)
+            return;
+        for (const record of records) {
+            for (const node of record.addedNodes) {
+                walkAndApplyNonce(node, nonce);
+            }
+        }
+    });
+    // Observe the full document because scripts can be injected into body/head by vendor/jQuery.
+    const root = documentRef.documentElement ?? documentRef;
+    observer.observe(root, { childList: true, subtree: true });
+    patchState.observerByDocument.set(documentRef, observer);
+}
+function teardownNonceMutationObserver(documentRef) {
+    const patchState = getDynamicScriptNoncePatchState();
+    const observer = patchState.observerByDocument.get(documentRef);
+    if (!observer)
+        return;
+    observer.disconnect();
+    patchState.observerByDocument.delete(documentRef);
+}
+function patchDynamicScriptInsertion() {
+    const patchState = getDynamicScriptNoncePatchState();
+    if (patchState.patched) {
+        return;
+    }
+    const originalAppendChild = Node.prototype.appendChild;
+    const originalInsertBefore = Node.prototype.insertBefore;
+    const originalReplaceChild = Node.prototype.replaceChild;
+    Node.prototype.appendChild = function (node) {
+        // Vendor captcha injects an inline snippet with `currentLangCode` that crashes when appended twice.
+        if (shouldSkipDuplicateInlineCaptchaScript(node)) {
+            return node;
+        }
+        applyTrackedNonce(node);
+        return originalAppendChild.call(this, node);
+    };
+    Node.prototype.insertBefore = function (node, child) {
+        if (shouldSkipDuplicateInlineCaptchaScript(node)) {
+            return node;
+        }
+        applyTrackedNonce(node);
+        return originalInsertBefore.call(this, node, child);
+    };
+    Node.prototype.replaceChild = function (node, child) {
+        applyTrackedNonce(node);
+        return originalReplaceChild.call(this, node, child);
+    };
+    patchState.patched = true;
+}
+export function resolveCspNonce(documentRef, explicitNonce) {
+    const resolvedExplicitNonce = normalizeNonce(explicitNonce);
+    if (resolvedExplicitNonce) {
+        return resolvedExplicitNonce;
+    }
+    const scriptWithNonce = documentRef.querySelector('script[nonce]');
+    const nonceFromScript = normalizeNonce(scriptWithNonce?.getAttribute('nonce') ?? scriptWithNonce?.nonce);
+    if (nonceFromScript) {
+        return nonceFromScript;
+    }
+    const nonceMeta = documentRef.querySelector('meta[name="csp-nonce"]');
+    return normalizeNonce(nonceMeta?.content);
+}
+export function prepareScriptNonce(documentRef, explicitNonce) {
+    const resolvedNonce = resolveCspNonce(documentRef, explicitNonce);
+    const patchState = getDynamicScriptNoncePatchState();
+    if (resolvedNonce) {
+        // DOM patching is only needed when a CSP nonce must be propagated.
+        patchDynamicScriptInsertion();
+        patchState.nonceByDocument.set(documentRef, resolvedNonce);
+        ensureNonceMutationObserver(documentRef);
+    }
+    else {
+        patchState.nonceByDocument.delete(documentRef);
+        teardownNonceMutationObserver(documentRef);
+    }
+    return resolvedNonce;
+}
+export function loadScript(documentRef, src, options) {
+    const nonce = prepareScriptNonce(documentRef, options?.nonce);
+    const statusBySrc = getStatusBySrc(documentRef);
+    const pendingBySrc = getPendingBySrc(documentRef);
+    const existing = documentRef.querySelector(`script[src="${src}"]`);
+    if (existing) {
+        applyScriptNonce(existing, nonce);
+        const status = statusBySrc.get(src);
+        if (status === 'loaded') {
+            return Promise.resolve();
+        }
+        const pending = pendingBySrc.get(src);
+        if (pending) {
+            return pending;
+        }
+        return Promise.resolve();
+    }
+    statusBySrc.set(src, 'loading');
+    const pending = new Promise((resolve, reject) => {
+        const script = documentRef.createElement('script');
+        script.src = src;
+        script.async = true;
+        applyScriptNonce(script, nonce);
+        script.onload = () => {
+            statusBySrc.set(src, 'loaded');
+            pendingBySrc.delete(src);
+            resolve();
+        };
+        script.onerror = () => {
+            statusBySrc.set(src, 'error');
+            pendingBySrc.delete(src);
+            reject(new Error(`Failed to load script: ${src}. Check CSP allowlist and nonce configuration.`));
+        };
+        documentRef.head.appendChild(script);
+    });
+    pendingBySrc.set(src, pending);
+    return pending;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"siara-shield-script-utils.js","sourceRoot":"","sources":["../../../../projects/siarashield-workspace/src/lib/siara-shield-script-utils.ts"],"names":[],"mappings":"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","sourcesContent":["type ScriptStatus = 'loading' | 'loaded' | 'error';\n\nexport interface ScriptLoadOptions {\n  nonce?: string;\n}\n\ninterface DynamicScriptNoncePatchState {\n  nonceByDocument: WeakMap<Document, string>;\n  observerByDocument: WeakMap<Document, MutationObserver>;\n  inlineCaptchaScriptByDocument: WeakMap<Document, Set<string>>;\n  patched: boolean;\n}\n\nconst SCRIPT_STATUS_BY_DOCUMENT = new WeakMap<Document, Map<string, ScriptStatus>>();\nconst SCRIPT_PENDING_BY_DOCUMENT = new WeakMap<Document, Map<string, Promise<void>>>();\nconst DYNAMIC_SCRIPT_NONCE_STATE_KEY = '__siaraShieldDynamicScriptNonceState__';\n\nfunction getStatusBySrc(documentRef: Document): Map<string, ScriptStatus> {\n  let statusBySrc = SCRIPT_STATUS_BY_DOCUMENT.get(documentRef);\n  if (!statusBySrc) {\n    statusBySrc = new Map<string, ScriptStatus>();\n    SCRIPT_STATUS_BY_DOCUMENT.set(documentRef, statusBySrc);\n  }\n\n  return statusBySrc;\n}\n\nfunction getPendingBySrc(documentRef: Document): Map<string, Promise<void>> {\n  let pendingBySrc = SCRIPT_PENDING_BY_DOCUMENT.get(documentRef);\n  if (!pendingBySrc) {\n    pendingBySrc = new Map<string, Promise<void>>();\n    SCRIPT_PENDING_BY_DOCUMENT.set(documentRef, pendingBySrc);\n  }\n\n  return pendingBySrc;\n}\n\nfunction getDynamicScriptNoncePatchState(): DynamicScriptNoncePatchState {\n  const globalState = globalThis as typeof globalThis & {\n    [DYNAMIC_SCRIPT_NONCE_STATE_KEY]?: DynamicScriptNoncePatchState;\n  };\n\n  if (!globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY]) {\n    globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY] = {\n      nonceByDocument: new WeakMap<Document, string>(),\n      observerByDocument: new WeakMap<Document, MutationObserver>(),\n      inlineCaptchaScriptByDocument: new WeakMap<Document, Set<string>>(),\n      patched: false,\n    };\n  }\n\n  return globalState[DYNAMIC_SCRIPT_NONCE_STATE_KEY];\n}\n\nfunction normalizeNonce(nonce?: string | null): string | undefined {\n  const trimmed = nonce?.trim();\n  return trimmed ? trimmed : undefined;\n}\n\nfunction isScriptElement(node: Node): node is HTMLScriptElement {\n  return node instanceof Element && node.tagName.toLowerCase() === 'script';\n}\n\nexport function applyScriptNonce(script: HTMLScriptElement, nonce?: string): void {\n  const resolvedNonce = normalizeNonce(nonce);\n  if (!resolvedNonce) {\n    return;\n  }\n\n  script.setAttribute('nonce', resolvedNonce);\n  script.nonce = resolvedNonce;\n}\n\nfunction applyTrackedNonce(node: Node): void {\n  if (!isScriptElement(node)) {\n    return;\n  }\n\n  const documentRef = node.ownerDocument;\n  if (!documentRef) {\n    return;\n  }\n\n  const nonce = getDynamicScriptNoncePatchState().nonceByDocument.get(documentRef);\n  applyScriptNonce(node, nonce);\n}\n\nfunction getTrackedInlineCaptchaScripts(documentRef: Document): Set<string> {\n  const patchState = getDynamicScriptNoncePatchState();\n  let trackedScripts = patchState.inlineCaptchaScriptByDocument.get(documentRef);\n  if (!trackedScripts) {\n    trackedScripts = new Set<string>();\n    patchState.inlineCaptchaScriptByDocument.set(documentRef, trackedScripts);\n  }\n\n  return trackedScripts;\n}\n\nfunction shouldSkipDuplicateInlineCaptchaScript(node: Node): boolean {\n  if (!isScriptElement(node) || Boolean(node.src)) {\n    return false;\n  }\n\n  const scriptBody = (node.textContent ?? '').trim();\n  if (!scriptBody || !scriptBody.includes('currentLangCode')) {\n    return false;\n  }\n\n  const documentRef = node.ownerDocument;\n  if (!documentRef) {\n    return false;\n  }\n\n  const trackedScripts = getTrackedInlineCaptchaScripts(documentRef);\n  if (trackedScripts.has(scriptBody)) {\n    return true;\n  }\n\n  trackedScripts.add(scriptBody);\n  return false;\n}\n\nfunction walkAndApplyNonce(root: Node, nonce?: string): void {\n  if (!nonce) return;\n\n  // Fast path: root itself is a script.\n  if (isScriptElement(root)) {\n    applyScriptNonce(root, nonce);\n    return;\n  }\n\n  // Common path for jQuery: append DocumentFragment containing scripts created via HTML parsing.\n  if (root instanceof Element || root instanceof DocumentFragment) {\n    const scripts = root.querySelectorAll?.('script') ?? [];\n    for (const script of scripts) {\n      applyScriptNonce(script as HTMLScriptElement, nonce);\n    }\n  }\n}\n\nfunction ensureNonceMutationObserver(documentRef: Document): void {\n  const patchState = getDynamicScriptNoncePatchState();\n  if (patchState.observerByDocument.get(documentRef)) {\n    return;\n  }\n\n  const observer = new MutationObserver((records) => {\n    const nonce = patchState.nonceByDocument.get(documentRef);\n    if (!nonce) return;\n\n    for (const record of records) {\n      for (const node of record.addedNodes) {\n        walkAndApplyNonce(node, nonce);\n      }\n    }\n  });\n\n  // Observe the full document because scripts can be injected into body/head by vendor/jQuery.\n  const root = documentRef.documentElement ?? documentRef;\n  observer.observe(root, { childList: true, subtree: true });\n  patchState.observerByDocument.set(documentRef, observer);\n}\n\nfunction teardownNonceMutationObserver(documentRef: Document): void {\n  const patchState = getDynamicScriptNoncePatchState();\n  const observer = patchState.observerByDocument.get(documentRef);\n  if (!observer) return;\n  observer.disconnect();\n  patchState.observerByDocument.delete(documentRef);\n}\n\nfunction patchDynamicScriptInsertion(): void {\n  const patchState = getDynamicScriptNoncePatchState();\n  if (patchState.patched) {\n    return;\n  }\n\n  const originalAppendChild = Node.prototype.appendChild;\n  const originalInsertBefore = Node.prototype.insertBefore;\n  const originalReplaceChild = Node.prototype.replaceChild;\n\n  Node.prototype.appendChild = function <T extends Node>(node: T): T {\n    // Vendor captcha injects an inline snippet with `currentLangCode` that crashes when appended twice.\n    if (shouldSkipDuplicateInlineCaptchaScript(node)) {\n      return node;\n    }\n    applyTrackedNonce(node);\n    return originalAppendChild.call(this, node) as T;\n  };\n\n  Node.prototype.insertBefore = function <T extends Node>(node: T, child: Node | null): T {\n    if (shouldSkipDuplicateInlineCaptchaScript(node)) {\n      return node;\n    }\n    applyTrackedNonce(node);\n    return originalInsertBefore.call(this, node, child) as T;\n  };\n\n  Node.prototype.replaceChild = function <T extends Node>(node: Node, child: T): T {\n    applyTrackedNonce(node);\n    return originalReplaceChild.call(this, node, child) as T;\n  };\n\n  patchState.patched = true;\n}\n\nexport function resolveCspNonce(documentRef: Document, explicitNonce?: string): string | undefined {\n  const resolvedExplicitNonce = normalizeNonce(explicitNonce);\n  if (resolvedExplicitNonce) {\n    return resolvedExplicitNonce;\n  }\n\n  const scriptWithNonce = documentRef.querySelector<HTMLScriptElement>('script[nonce]');\n  const nonceFromScript = normalizeNonce(scriptWithNonce?.getAttribute('nonce') ?? scriptWithNonce?.nonce);\n  if (nonceFromScript) {\n    return nonceFromScript;\n  }\n\n  const nonceMeta = documentRef.querySelector<HTMLMetaElement>('meta[name=\"csp-nonce\"]');\n  return normalizeNonce(nonceMeta?.content);\n}\n\nexport function prepareScriptNonce(documentRef: Document, explicitNonce?: string): string | undefined {\n  const resolvedNonce = resolveCspNonce(documentRef, explicitNonce);\n  const patchState = getDynamicScriptNoncePatchState();\n\n  if (resolvedNonce) {\n    // DOM patching is only needed when a CSP nonce must be propagated.\n    patchDynamicScriptInsertion();\n    patchState.nonceByDocument.set(documentRef, resolvedNonce);\n    ensureNonceMutationObserver(documentRef);\n  } else {\n    patchState.nonceByDocument.delete(documentRef);\n    teardownNonceMutationObserver(documentRef);\n  }\n\n  return resolvedNonce;\n}\n\nexport function loadScript(documentRef: Document, src: string, options?: ScriptLoadOptions): Promise<void> {\n  const nonce = prepareScriptNonce(documentRef, options?.nonce);\n  const statusBySrc = getStatusBySrc(documentRef);\n  const pendingBySrc = getPendingBySrc(documentRef);\n  const existing = documentRef.querySelector<HTMLScriptElement>(`script[src=\"${src}\"]`);\n\n  if (existing) {\n    applyScriptNonce(existing, nonce);\n    const status = statusBySrc.get(src);\n    if (status === 'loaded') {\n      return Promise.resolve();\n    }\n\n    const pending = pendingBySrc.get(src);\n    if (pending) {\n      return pending;\n    }\n\n    return Promise.resolve();\n  }\n\n  statusBySrc.set(src, 'loading');\n\n  const pending = new Promise<void>((resolve, reject) => {\n    const script = documentRef.createElement('script');\n    script.src = src;\n    script.async = true;\n    applyScriptNonce(script, nonce);\n    script.onload = () => {\n      statusBySrc.set(src, 'loaded');\n      pendingBySrc.delete(src);\n      resolve();\n    };\n    script.onerror = () => {\n      statusBySrc.set(src, 'error');\n      pendingBySrc.delete(src);\n      reject(new Error(`Failed to load script: ${src}. Check CSP allowlist and nonce configuration.`));\n    };\n    documentRef.head.appendChild(script);\n  });\n\n  pendingBySrc.set(src, pending);\n  return pending;\n}\n"]}

package/esm2022/lib/siara-shield-submit-guard.mjs

@@ -0,0 +1,30 @@
+const SUBMIT_GUARD_STATE_KEY = '__siaraShieldSubmitGuardInstalled__';
+const SYNTHETIC_CLICK_GUARD_WINDOW_MS = 1200;
+export function installCaptchaSubmitGuard() {
+    const globalState = globalThis;
+    if (globalState[SUBMIT_GUARD_STATE_KEY])
+        return;
+    const lastSyntheticClickByButton = new WeakMap();
+    document.addEventListener('click', (event) => {
+        const target = event.target;
+        if (!(target instanceof Element))
+            return;
+        const submitButton = target.closest('.CaptchaSubmit');
+        if (!submitButton)
+            return;
+        // Vendor runtime can emit synthetic clicks on .CaptchaSubmit.
+        // Allow one synthetic click (needed for vendor auto-submit) but block rapid duplicates.
+        if (!event.isTrusted) {
+            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);
+        }
+    }, true);
+    globalState[SUBMIT_GUARD_STATE_KEY] = true;
+}
+//# sourceMappingURL=data:application/json;base64,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