@consentx/angular 1.0.0

package/dist/esm2022/lib/consentx.providers.mjs

@@ -0,0 +1,51 @@
+import { APP_INITIALIZER, makeEnvironmentProviders, } from '@angular/core';
+import { CONSENTX_CONFIG } from './consentx.tokens';
+import { ConsentXService } from './consentx.service';
+/**
+ * Factory used by APP_INITIALIZER. Initialising on app boot means the embed is
+ * injected once the Angular application is ready (i.e. after hydration on SSR),
+ * which is the SPA-safe load point the Connect spec recommends so the
+ * framework's DOM reconciliation does not strip the appended
+ * `#consentx-cookie-consent` div.
+ */
+export function consentxInitFactory(service) {
+    return () => service.init();
+}
+/**
+ * Standalone-app provider. Use in `bootstrapApplication(...)`:
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideConsentX({ siteKey: 'YOUR_SITE_KEY' })],
+ * });
+ * ```
+ */
+export function provideConsentX(config) {
+    return makeEnvironmentProviders([
+        { provide: CONSENTX_CONFIG, useValue: config },
+        ConsentXService,
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: consentxInitFactory,
+            deps: [ConsentXService],
+        },
+    ]);
+}
+/**
+ * Internal: the providers `ConsentXModule.forRoot()` contributes. Kept separate
+ * so both the NgModule and the standalone API share one source of truth.
+ */
+export function consentxRootProviders(config) {
+    return [
+        { provide: CONSENTX_CONFIG, useValue: config },
+        ConsentXService,
+        {
+            provide: APP_INITIALIZER,
+            multi: true,
+            useFactory: consentxInitFactory,
+            deps: [ConsentXService],
+        },
+    ];
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/lib/consentx.service.mjs

@@ -0,0 +1,230 @@
+import { Inject, Injectable, Optional, PLATFORM_ID, } from '@angular/core';
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { BehaviorSubject } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { CONSENTX_CONFIG } from './consentx.tokens';
+import { CONSENTX_DEFAULT_APP_URL, } from './consentx.types';
+import * as i0 from "@angular/core";
+const SCRIPT_ID = 'consentx-embed';
+const CONSENT_MODE_ID = 'consentx-consent-mode';
+/**
+ * Injects the ConsentX embed script (`/api/SITE_KEY/embed.js`) into `<head>`
+ * and exposes the visitor's consent state, derived from the widget's
+ * `cx:consent` events.
+ *
+ * Site-key model (Connect spec, Model C): no redirect handshake. The Site Key
+ * is supplied via configuration; this service only performs clean embed
+ * injection plus a consent hook.
+ *
+ * The service is `providedIn: 'root'` so it is a singleton across the app. It
+ * is SSR-safe: all DOM access is guarded behind `isPlatformBrowser`, so it is a
+ * no-op on the server and runs once the app boots in the browser.
+ */
+export class ConsentXService {
+    config;
+    document;
+    zone;
+    appUrl;
+    isBrowser;
+    listenerBound = false;
+    boundConsentListener;
+    stateSubject = new BehaviorSubject({
+        loaded: false,
+        decided: false,
+        granted: [],
+        detail: null,
+    });
+    /** Full consent state as an observable. Emits an initial snapshot. */
+    state$ = this.stateSubject.asObservable();
+    /** Convenience stream of the granted category slugs. */
+    granted$ = this.state$.pipe(map((s) => s.granted), distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i])));
+    constructor(config, platformId, document, zone) {
+        this.config = config;
+        this.document = document;
+        this.zone = zone;
+        this.isBrowser = isPlatformBrowser(platformId);
+        this.appUrl = this.normalizeAppUrl(this.config?.appUrl);
+        if (!this.config?.siteKey) {
+            // Misconfiguration is loud but non-fatal: the app keeps working without
+            // the banner instead of crashing bootstrap.
+            // eslint-disable-next-line no-console
+            console.error('[ConsentX] No siteKey provided. Pass { siteKey } to ConsentXModule.forRoot() ' +
+                'or provideConsentX(). Copy the Site Key from the ConsentX dashboard -> ' +
+                'Websites -> your site.');
+        }
+    }
+    /**
+     * Auto-init entry point. Called once during app initialisation (via an
+     * APP_INITIALIZER registered by the module/provider) unless `manualLoad` is
+     * set. Binds the consent listener and injects the embed.
+     */
+    init() {
+        if (!this.isBrowser) {
+            return;
+        }
+        this.bindConsentListener();
+        if (!this.config?.manualLoad) {
+            this.load();
+        }
+    }
+    /**
+     * Inject the ConsentX embed into `<head>`. Idempotent: a second call is a
+     * no-op if the script is already present. Safe to call manually when
+     * `manualLoad` is enabled (e.g. after a cookie-policy route is reached).
+     */
+    load() {
+        if (!this.isBrowser) {
+            return;
+        }
+        const siteKey = this.config?.siteKey?.trim();
+        if (!siteKey) {
+            return;
+        }
+        this.bindConsentListener();
+        if (this.config?.consentMode) {
+            this.injectConsentModeDefaults();
+        }
+        // Expose the key the way embed.js expects (window.consentx_key), matching
+        // the canonical embed contract.
+        this.document.defaultView.consentx_key = siteKey;
+        if (this.document.getElementById(SCRIPT_ID)) {
+            // Already injected — make sure the loaded flag reflects reality.
+            this.patchState({ loaded: true });
+            return;
+        }
+        const head = this.document.head || this.document.getElementsByTagName('head')[0];
+        if (!head) {
+            return;
+        }
+        const script = this.document.createElement('script');
+        script.id = SCRIPT_ID;
+        script.type = 'module';
+        script.src = `${this.appUrl}/api/${encodeURIComponent(siteKey)}/embed.js`;
+        script.setAttribute('data-consentx', siteKey);
+        script.async = true;
+        script.addEventListener('load', () => {
+            this.zone.run(() => this.patchState({ loaded: true }));
+        });
+        script.addEventListener('error', () => {
+            // eslint-disable-next-line no-console
+            console.error(`[ConsentX] Failed to load embed from ${script.src}`);
+        });
+        head.appendChild(script);
+    }
+    /**
+     * Open the ConsentX preferences dialog. Requires the embed to have loaded and
+     * exposed `window.ConsentX`. Returns `true` if the call was dispatched.
+     */
+    openPreferences() {
+        if (!this.isBrowser) {
+            return false;
+        }
+        const api = this.document.defaultView?.ConsentX;
+        if (api && typeof api.open === 'function') {
+            api.open();
+            return true;
+        }
+        return false;
+    }
+    /** Latest granted category slugs (synchronous snapshot). */
+    getGranted() {
+        return this.stateSubject.value.granted;
+    }
+    /**
+     * Whether the visitor has granted a specific consent category slug, e.g.
+     * `hasConsent('analytics')`.
+     */
+    hasConsent(slug) {
+        return this.stateSubject.value.granted.includes(slug);
+    }
+    /** Current full state snapshot (synchronous). */
+    getState() {
+        return this.stateSubject.value;
+    }
+    ngOnDestroy() {
+        if (this.isBrowser && this.boundConsentListener) {
+            this.document.defaultView?.removeEventListener('cx:consent', this.boundConsentListener);
+        }
+    }
+    // --- internals -----------------------------------------------------------
+    /**
+     * Print the Google Consent Mode v2 denied-by-default stub before any
+     * analytics tag fires. Idempotent. Mirrors the canonical embed contract.
+     */
+    injectConsentModeDefaults() {
+        const win = this.document.defaultView;
+        if (!win) {
+            return;
+        }
+        if (this.document.getElementById(CONSENT_MODE_ID)) {
+            return;
+        }
+        win.dataLayer = win.dataLayer || [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const gtag = (...args) => win.dataLayer.push(args);
+        gtag('consent', 'default', {
+            ad_storage: 'denied',
+            analytics_storage: 'denied',
+            ad_user_data: 'denied',
+            ad_personalization: 'denied',
+            functionality_storage: 'denied',
+            personalization_storage: 'denied',
+            security_storage: 'granted',
+            wait_for_update: 500,
+        });
+        // Marker so a second call (or a duplicate inline tag) is a no-op.
+        const marker = this.document.createElement('script');
+        marker.id = CONSENT_MODE_ID;
+        marker.type = 'application/json';
+        marker.textContent = '{"consentx":"consent-mode-defaults"}';
+        (this.document.head || this.document.documentElement).appendChild(marker);
+    }
+    /** Subscribe to the widget's `cx:consent` events exactly once. */
+    bindConsentListener() {
+        if (this.listenerBound || !this.isBrowser) {
+            return;
+        }
+        const win = this.document.defaultView;
+        if (!win) {
+            return;
+        }
+        this.boundConsentListener = (event) => {
+            const detail = event.detail;
+            const granted = Array.isArray(detail?.granted) ? detail.granted : [];
+            // Re-enter Angular so bound templates/observables update.
+            this.zone.run(() => this.patchState({
+                decided: true,
+                granted,
+                detail: detail ?? null,
+            }));
+        };
+        win.addEventListener('cx:consent', this.boundConsentListener);
+        this.listenerBound = true;
+    }
+    patchState(partial) {
+        this.stateSubject.next({ ...this.stateSubject.value, ...partial });
+    }
+    /** Resolve + sanitise the app host (strip trailing slash). */
+    normalizeAppUrl(url) {
+        const raw = (url || CONSENTX_DEFAULT_APP_URL).trim();
+        return raw.replace(/\/+$/, '');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConsentXService, deps: [{ token: CONSENTX_CONFIG, optional: true }, { token: PLATFORM_ID }, { token: DOCUMENT }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConsentXService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ConsentXService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [CONSENTX_CONFIG]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.NgZone }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"consentx.service.js","sourceRoot":"","sources":["../../../src/lib/consentx.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Inject,\n  Injectable,\n  NgZone,\n  OnDestroy,\n  Optional,\n  PLATFORM_ID,\n} from '@angular/core';\nimport { DOCUMENT, isPlatformBrowser } from '@angular/common';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { distinctUntilChanged, map } from 'rxjs/operators';\n\nimport { CONSENTX_CONFIG } from './consentx.tokens';\nimport {\n  CONSENTX_DEFAULT_APP_URL,\n  ConsentGranted,\n  ConsentXConfig,\n  ConsentXConsentDetail,\n  ConsentXState,\n} from './consentx.types';\n\nconst SCRIPT_ID = 'consentx-embed';\nconst CONSENT_MODE_ID = 'consentx-consent-mode';\n\n/**\n * Injects the ConsentX embed script (`/api/SITE_KEY/embed.js`) into `<head>`\n * and exposes the visitor's consent state, derived from the widget's\n * `cx:consent` events.\n *\n * Site-key model (Connect spec, Model C): no redirect handshake. The Site Key\n * is supplied via configuration; this service only performs clean embed\n * injection plus a consent hook.\n *\n * The service is `providedIn: 'root'` so it is a singleton across the app. It\n * is SSR-safe: all DOM access is guarded behind `isPlatformBrowser`, so it is a\n * no-op on the server and runs once the app boots in the browser.\n */\n@Injectable({ providedIn: 'root' })\nexport class ConsentXService implements OnDestroy {\n  private readonly appUrl: string;\n  private readonly isBrowser: boolean;\n  private listenerBound = false;\n  private boundConsentListener?: (event: Event) => void;\n\n  private readonly stateSubject = new BehaviorSubject<ConsentXState>({\n    loaded: false,\n    decided: false,\n    granted: [],\n    detail: null,\n  });\n\n  /** Full consent state as an observable. Emits an initial snapshot. */\n  readonly state$: Observable<ConsentXState> = this.stateSubject.asObservable();\n\n  /** Convenience stream of the granted category slugs. */\n  readonly granted$: Observable<ConsentGranted> = this.state$.pipe(\n    map((s) => s.granted),\n    distinctUntilChanged((a, b) => a.length === b.length && a.every((v, i) => v === b[i])),\n  );\n\n  constructor(\n    @Optional() @Inject(CONSENTX_CONFIG) private readonly config: ConsentXConfig | null,\n    @Inject(PLATFORM_ID) platformId: object,\n    @Inject(DOCUMENT) private readonly document: Document,\n    private readonly zone: NgZone,\n  ) {\n    this.isBrowser = isPlatformBrowser(platformId);\n    this.appUrl = this.normalizeAppUrl(this.config?.appUrl);\n\n    if (!this.config?.siteKey) {\n      // Misconfiguration is loud but non-fatal: the app keeps working without\n      // the banner instead of crashing bootstrap.\n      // eslint-disable-next-line no-console\n      console.error(\n        '[ConsentX] No siteKey provided. Pass { siteKey } to ConsentXModule.forRoot() ' +\n          'or provideConsentX(). Copy the Site Key from the ConsentX dashboard -> ' +\n          'Websites -> your site.',\n      );\n    }\n  }\n\n  /**\n   * Auto-init entry point. Called once during app initialisation (via an\n   * APP_INITIALIZER registered by the module/provider) unless `manualLoad` is\n   * set. Binds the consent listener and injects the embed.\n   */\n  init(): void {\n    if (!this.isBrowser) {\n      return;\n    }\n    this.bindConsentListener();\n    if (!this.config?.manualLoad) {\n      this.load();\n    }\n  }\n\n  /**\n   * Inject the ConsentX embed into `<head>`. Idempotent: a second call is a\n   * no-op if the script is already present. Safe to call manually when\n   * `manualLoad` is enabled (e.g. after a cookie-policy route is reached).\n   */\n  load(): void {\n    if (!this.isBrowser) {\n      return;\n    }\n    const siteKey = this.config?.siteKey?.trim();\n    if (!siteKey) {\n      return;\n    }\n\n    this.bindConsentListener();\n\n    if (this.config?.consentMode) {\n      this.injectConsentModeDefaults();\n    }\n\n    // Expose the key the way embed.js expects (window.consentx_key), matching\n    // the canonical embed contract.\n    this.document.defaultView!.consentx_key = siteKey;\n\n    if (this.document.getElementById(SCRIPT_ID)) {\n      // Already injected — make sure the loaded flag reflects reality.\n      this.patchState({ loaded: true });\n      return;\n    }\n\n    const head = this.document.head || this.document.getElementsByTagName('head')[0];\n    if (!head) {\n      return;\n    }\n\n    const script = this.document.createElement('script');\n    script.id = SCRIPT_ID;\n    script.type = 'module';\n    script.src = `${this.appUrl}/api/${encodeURIComponent(siteKey)}/embed.js`;\n    script.setAttribute('data-consentx', siteKey);\n    script.async = true;\n\n    script.addEventListener('load', () => {\n      this.zone.run(() => this.patchState({ loaded: true }));\n    });\n    script.addEventListener('error', () => {\n      // eslint-disable-next-line no-console\n      console.error(`[ConsentX] Failed to load embed from ${script.src}`);\n    });\n\n    head.appendChild(script);\n  }\n\n  /**\n   * Open the ConsentX preferences dialog. Requires the embed to have loaded and\n   * exposed `window.ConsentX`. Returns `true` if the call was dispatched.\n   */\n  openPreferences(): boolean {\n    if (!this.isBrowser) {\n      return false;\n    }\n    const api = this.document.defaultView?.ConsentX;\n    if (api && typeof api.open === 'function') {\n      api.open();\n      return true;\n    }\n    return false;\n  }\n\n  /** Latest granted category slugs (synchronous snapshot). */\n  getGranted(): ConsentGranted {\n    return this.stateSubject.value.granted;\n  }\n\n  /**\n   * Whether the visitor has granted a specific consent category slug, e.g.\n   * `hasConsent('analytics')`.\n   */\n  hasConsent(slug: string): boolean {\n    return this.stateSubject.value.granted.includes(slug);\n  }\n\n  /** Current full state snapshot (synchronous). */\n  getState(): ConsentXState {\n    return this.stateSubject.value;\n  }\n\n  ngOnDestroy(): void {\n    if (this.isBrowser && this.boundConsentListener) {\n      this.document.defaultView?.removeEventListener(\n        'cx:consent',\n        this.boundConsentListener as EventListener,\n      );\n    }\n  }\n\n  // --- internals -----------------------------------------------------------\n\n  /**\n   * Print the Google Consent Mode v2 denied-by-default stub before any\n   * analytics tag fires. Idempotent. Mirrors the canonical embed contract.\n   */\n  private injectConsentModeDefaults(): void {\n    const win = this.document.defaultView;\n    if (!win) {\n      return;\n    }\n    if (this.document.getElementById(CONSENT_MODE_ID)) {\n      return;\n    }\n    win.dataLayer = win.dataLayer || [];\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const gtag = (...args: unknown[]) => (win.dataLayer as any[]).push(args);\n    gtag('consent', 'default', {\n      ad_storage: 'denied',\n      analytics_storage: 'denied',\n      ad_user_data: 'denied',\n      ad_personalization: 'denied',\n      functionality_storage: 'denied',\n      personalization_storage: 'denied',\n      security_storage: 'granted',\n      wait_for_update: 500,\n    });\n    // Marker so a second call (or a duplicate inline tag) is a no-op.\n    const marker = this.document.createElement('script');\n    marker.id = CONSENT_MODE_ID;\n    marker.type = 'application/json';\n    marker.textContent = '{\"consentx\":\"consent-mode-defaults\"}';\n    (this.document.head || this.document.documentElement).appendChild(marker);\n  }\n\n  /** Subscribe to the widget's `cx:consent` events exactly once. */\n  private bindConsentListener(): void {\n    if (this.listenerBound || !this.isBrowser) {\n      return;\n    }\n    const win = this.document.defaultView;\n    if (!win) {\n      return;\n    }\n    this.boundConsentListener = (event: Event) => {\n      const detail = (event as CustomEvent<ConsentXConsentDetail>).detail;\n      const granted = Array.isArray(detail?.granted) ? detail!.granted : [];\n      // Re-enter Angular so bound templates/observables update.\n      this.zone.run(() =>\n        this.patchState({\n          decided: true,\n          granted,\n          detail: detail ?? null,\n        }),\n      );\n    };\n    win.addEventListener('cx:consent', this.boundConsentListener as EventListener);\n    this.listenerBound = true;\n  }\n\n  private patchState(partial: Partial<ConsentXState>): void {\n    this.stateSubject.next({ ...this.stateSubject.value, ...partial });\n  }\n\n  /** Resolve + sanitise the app host (strip trailing slash). */\n  private normalizeAppUrl(url?: string): string {\n    const raw = (url || CONSENTX_DEFAULT_APP_URL).trim();\n    return raw.replace(/\\/+$/, '');\n  }\n}\n"]}

package/dist/esm2022/lib/consentx.tokens.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * DI token carrying the resolved {@link ConsentXConfig}. Provided by
+ * `ConsentXModule.forRoot(...)` or `provideConsentX(...)`.
+ */
+export const CONSENTX_CONFIG = new InjectionToken('CONSENTX_CONFIG');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc2VudHgudG9rZW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9jb25zZW50eC50b2tlbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSxlQUFlLEdBQUcsSUFBSSxjQUFjLENBQWlCLGlCQUFpQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29uc2VudFhDb25maWcgfSBmcm9tICcuL2NvbnNlbnR4LnR5cGVzJztcblxuLyoqXG4gKiBESSB0b2tlbiBjYXJyeWluZyB0aGUgcmVzb2x2ZWQge0BsaW5rIENvbnNlbnRYQ29uZmlnfS4gUHJvdmlkZWQgYnlcbiAqIGBDb25zZW50WE1vZHVsZS5mb3JSb290KC4uLilgIG9yIGBwcm92aWRlQ29uc2VudFgoLi4uKWAuXG4gKi9cbmV4cG9ydCBjb25zdCBDT05TRU5UWF9DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48Q29uc2VudFhDb25maWc+KCdDT05TRU5UWF9DT05GSUcnKTtcbiJdfQ==

package/dist/esm2022/lib/consentx.types.mjs

@@ -0,0 +1,11 @@
+/**
+ * Public types for @consentx/angular.
+ *
+ * ConsentX runs on the site-key model (Model C in the Connect spec): the user
+ * pastes the Site Key copied from the ConsentX dashboard (Websites -> their
+ * site) and ensures their domain is on that site's allowlist. The embed then
+ * loads with no server-side handshake.
+ */
+/** Default ConsentX application host (no trailing slash). */
+export const CONSENTX_DEFAULT_APP_URL = 'https://app.consentx.io';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/public-api.mjs

@@ -0,0 +1,9 @@
+/*
+ * Public API surface of @consentx/angular.
+ */
+export { ConsentXModule } from './lib/consentx.module';
+export { ConsentXService } from './lib/consentx.service';
+export { provideConsentX, consentxInitFactory, consentxRootProviders, } from './lib/consentx.providers';
+export { CONSENTX_CONFIG } from './lib/consentx.tokens';
+export { CONSENTX_DEFAULT_APP_URL, } from './lib/consentx.types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUN6RCxPQUFPLEVBQ0wsZUFBZSxFQUNmLG1CQUFtQixFQUNuQixxQkFBcUIsR0FDdEIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDeEQsT0FBTyxFQUNMLHdCQUF3QixHQU16QixNQUFNLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgc3VyZmFjZSBvZiBAY29uc2VudHgvYW5ndWxhci5cbiAqL1xuXG5leHBvcnQgeyBDb25zZW50WE1vZHVsZSB9IGZyb20gJy4vbGliL2NvbnNlbnR4Lm1vZHVsZSc7XG5leHBvcnQgeyBDb25zZW50WFNlcnZpY2UgfSBmcm9tICcuL2xpYi9jb25zZW50eC5zZXJ2aWNlJztcbmV4cG9ydCB7XG4gIHByb3ZpZGVDb25zZW50WCxcbiAgY29uc2VudHhJbml0RmFjdG9yeSxcbiAgY29uc2VudHhSb290UHJvdmlkZXJzLFxufSBmcm9tICcuL2xpYi9jb25zZW50eC5wcm92aWRlcnMnO1xuZXhwb3J0IHsgQ09OU0VOVFhfQ09ORklHIH0gZnJvbSAnLi9saWIvY29uc2VudHgudG9rZW5zJztcbmV4cG9ydCB7XG4gIENPTlNFTlRYX0RFRkFVTFRfQVBQX1VSTCxcbiAgQ29uc2VudFhDb25maWcsXG4gIENvbnNlbnRYU3RhdGUsXG4gIENvbnNlbnRHcmFudGVkLFxuICBDb25zZW50WENvbnNlbnREZXRhaWwsXG4gIENvbnNlbnRYV2lkZ2V0QXBpLFxufSBmcm9tICcuL2xpYi9jb25zZW50eC50eXBlcyc7XG4iXX0=