ng-recaptcha-2 14.0.0

package/esm2022/lib/load-script.mjs

@@ -0,0 +1,28 @@
+function loadScript(renderMode, onBeforeLoad, onLoaded, { url, lang, nonce } = {}) {
+    window.ng2recaptchaloaded = () => {
+        onLoaded(grecaptcha);
+    };
+    const script = document.createElement("script");
+    script.innerHTML = "";
+    const { url: baseUrl, nonce: onBeforeLoadNonce } = onBeforeLoad(new URL(url || "https://www.google.com/recaptcha/api.js"));
+    baseUrl.searchParams.set("render", renderMode === "explicit" ? renderMode : renderMode.key);
+    baseUrl.searchParams.set("onload", "ng2recaptchaloaded");
+    baseUrl.searchParams.set("trustedtypes", "true");
+    if (lang) {
+        baseUrl.searchParams.set("hl", lang);
+    }
+    script.src = baseUrl.href;
+    const nonceValue = onBeforeLoadNonce || nonce;
+    if (nonceValue) {
+        script.setAttribute("nonce", nonceValue);
+    }
+    script.async = true;
+    script.defer = true;
+    document.head.appendChild(script);
+}
+function newLoadScript({ v3SiteKey, onBeforeLoad, onLoaded, }) {
+    const renderMode = v3SiteKey ? { key: v3SiteKey } : "explicit";
+    loader.loadScript(renderMode, onBeforeLoad, onLoaded);
+}
+export const loader = { loadScript, newLoadScript };
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/recaptcha-common.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from "@angular/core";
+import { RecaptchaComponent } from "./recaptcha.component";
+import * as i0 from "@angular/core";
+export class RecaptchaCommonModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaCommonModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaCommonModule, declarations: [RecaptchaComponent], exports: [RecaptchaComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaCommonModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaCommonModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [RecaptchaComponent],
+                    exports: [RecaptchaComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjYXB0Y2hhLWNvbW1vbi5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1yZWNhcHRjaGEvc3JjL2xpYi9yZWNhcHRjaGEtY29tbW9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU0zRCxNQUFNLE9BQU8scUJBQXFCOzhHQUFyQixxQkFBcUI7K0dBQXJCLHFCQUFxQixpQkFIakIsa0JBQWtCLGFBQ3ZCLGtCQUFrQjsrR0FFakIscUJBQXFCOzsyRkFBckIscUJBQXFCO2tCQUpqQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLGtCQUFrQixDQUFDO29CQUNsQyxPQUFPLEVBQUUsQ0FBQyxrQkFBa0IsQ0FBQztpQkFDOUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5cbmltcG9ydCB7IFJlY2FwdGNoYUNvbXBvbmVudCB9IGZyb20gXCIuL3JlY2FwdGNoYS5jb21wb25lbnRcIjtcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbUmVjYXB0Y2hhQ29tcG9uZW50XSxcbiAgZXhwb3J0czogW1JlY2FwdGNoYUNvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIFJlY2FwdGNoYUNvbW1vbk1vZHVsZSB7fVxuIl19

package/esm2022/lib/recaptcha-forms.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from "@angular/core";
+import { FormsModule } from "@angular/forms";
+import { RecaptchaCommonModule } from "./recaptcha-common.module";
+import { RecaptchaValueAccessorDirective } from "./recaptcha-value-accessor.directive";
+import * as i0 from "@angular/core";
+export class RecaptchaFormsModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaFormsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaFormsModule, declarations: [RecaptchaValueAccessorDirective], imports: [FormsModule, RecaptchaCommonModule], exports: [RecaptchaValueAccessorDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaFormsModule, imports: [FormsModule, RecaptchaCommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaFormsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [RecaptchaValueAccessorDirective],
+                    exports: [RecaptchaValueAccessorDirective],
+                    imports: [FormsModule, RecaptchaCommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjYXB0Y2hhLWZvcm1zLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXJlY2FwdGNoYS9zcmMvbGliL3JlY2FwdGNoYS1mb3Jtcy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0MsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFDbEUsT0FBTyxFQUFFLCtCQUErQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7O0FBT3ZGLE1BQU0sT0FBTyxvQkFBb0I7OEdBQXBCLG9CQUFvQjsrR0FBcEIsb0JBQW9CLGlCQUpoQiwrQkFBK0IsYUFFcEMsV0FBVyxFQUFFLHFCQUFxQixhQURsQywrQkFBK0I7K0dBRzlCLG9CQUFvQixZQUZyQixXQUFXLEVBQUUscUJBQXFCOzsyRkFFakMsb0JBQW9CO2tCQUxoQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLCtCQUErQixDQUFDO29CQUMvQyxPQUFPLEVBQUUsQ0FBQywrQkFBK0IsQ0FBQztvQkFDMUMsT0FBTyxFQUFFLENBQUMsV0FBVyxFQUFFLHFCQUFxQixDQUFDO2lCQUM5QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XG5cbmltcG9ydCB7IFJlY2FwdGNoYUNvbW1vbk1vZHVsZSB9IGZyb20gXCIuL3JlY2FwdGNoYS1jb21tb24ubW9kdWxlXCI7XG5pbXBvcnQgeyBSZWNhcHRjaGFWYWx1ZUFjY2Vzc29yRGlyZWN0aXZlIH0gZnJvbSBcIi4vcmVjYXB0Y2hhLXZhbHVlLWFjY2Vzc29yLmRpcmVjdGl2ZVwiO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtSZWNhcHRjaGFWYWx1ZUFjY2Vzc29yRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW1JlY2FwdGNoYVZhbHVlQWNjZXNzb3JEaXJlY3RpdmVdLFxuICBpbXBvcnRzOiBbRm9ybXNNb2R1bGUsIFJlY2FwdGNoYUNvbW1vbk1vZHVsZV0sXG59KVxuZXhwb3J0IGNsYXNzIFJlY2FwdGNoYUZvcm1zTW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/recaptcha-loader.service.mjs

@@ -0,0 +1,104 @@
+import { isPlatformBrowser } from "@angular/common";
+import { Inject, Injectable, Optional, PLATFORM_ID } from "@angular/core";
+import { BehaviorSubject, of } from "rxjs";
+import { filter } from "rxjs/operators";
+import { loader } from "./load-script";
+import { RECAPTCHA_LOADER_OPTIONS, RECAPTCHA_BASE_URL, RECAPTCHA_LANGUAGE, RECAPTCHA_NONCE, RECAPTCHA_V3_SITE_KEY, } from "./tokens";
+import * as i0 from "@angular/core";
+function toNonNullObservable(subject) {
+    return subject.asObservable().pipe(filter((value) => value !== null));
+}
+export class RecaptchaLoaderService {
+    /**
+     * @internal
+     * @nocollapse
+     */
+    static { this.ready = null; }
+    constructor(
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    platformId, 
+    // eslint-disable-next-line deprecation/deprecation
+    language, 
+    // eslint-disable-next-line deprecation/deprecation
+    baseUrl, 
+    // eslint-disable-next-line deprecation/deprecation
+    nonce, v3SiteKey, options) {
+        this.platformId = platformId;
+        this.language = language;
+        this.baseUrl = baseUrl;
+        this.nonce = nonce;
+        this.v3SiteKey = v3SiteKey;
+        this.options = options;
+        const subject = this.init();
+        this.ready = subject ? toNonNullObservable(subject) : of();
+    }
+    /** @internal */
+    init() {
+        if (RecaptchaLoaderService.ready) {
+            return RecaptchaLoaderService.ready;
+        }
+        if (!isPlatformBrowser(this.platformId)) {
+            return undefined;
+        }
+        const subject = new BehaviorSubject(null);
+        RecaptchaLoaderService.ready = subject;
+        loader.newLoadScript({
+            v3SiteKey: this.v3SiteKey,
+            onBeforeLoad: (url) => {
+                if (this.options?.onBeforeLoad) {
+                    return this.options.onBeforeLoad(url);
+                }
+                const newUrl = new URL(this.baseUrl ?? url);
+                if (this.language) {
+                    newUrl.searchParams.set("hl", this.language);
+                }
+                return {
+                    url: newUrl,
+                    nonce: this.nonce,
+                };
+            },
+            onLoaded: (recaptcha) => {
+                let value = recaptcha;
+                if (this.options?.onLoaded) {
+                    value = this.options.onLoaded(recaptcha);
+                }
+                subject.next(value);
+            },
+        });
+        return subject;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaLoaderService, deps: [{ token: PLATFORM_ID }, { token: RECAPTCHA_LANGUAGE, optional: true }, { token: RECAPTCHA_BASE_URL, optional: true }, { token: RECAPTCHA_NONCE, optional: true }, { token: RECAPTCHA_V3_SITE_KEY, optional: true }, { token: RECAPTCHA_LOADER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaLoaderService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaLoaderService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_LANGUAGE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_BASE_URL]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_NONCE]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_V3_SITE_KEY]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_LOADER_OPTIONS]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/recaptcha-settings.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjYXB0Y2hhLXNldHRpbmdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvbmctcmVjYXB0Y2hhL3NyYy9saWIvcmVjYXB0Y2hhLXNldHRpbmdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFJlY2FwdGNoYVNldHRpbmdzIHtcbiAgc2l0ZUtleT86IHN0cmluZztcbiAgdGhlbWU/OiBSZUNhcHRjaGFWMi5UaGVtZTtcbiAgdHlwZT86IFJlQ2FwdGNoYVYyLlR5cGU7XG4gIHNpemU/OiBSZUNhcHRjaGFWMi5TaXplO1xuICBiYWRnZT86IFJlQ2FwdGNoYVYyLkJhZGdlO1xufVxuIl19

package/esm2022/lib/recaptcha-v3.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from "@angular/core";
+import { ReCaptchaV3Service } from "./recaptcha-v3.service";
+import { RecaptchaLoaderService } from "./recaptcha-loader.service";
+import * as i0 from "@angular/core";
+export class RecaptchaV3Module {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaV3Module, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaV3Module }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaV3Module, providers: [ReCaptchaV3Service, RecaptchaLoaderService] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaV3Module, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [ReCaptchaV3Service, RecaptchaLoaderService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVjYXB0Y2hhLXYzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXJlY2FwdGNoYS9zcmMvbGliL3JlY2FwdGNoYS12My5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUM1RCxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQzs7QUFLcEUsTUFBTSxPQUFPLGlCQUFpQjs4R0FBakIsaUJBQWlCOytHQUFqQixpQkFBaUI7K0dBQWpCLGlCQUFpQixhQUZqQixDQUFDLGtCQUFrQixFQUFFLHNCQUFzQixDQUFDOzsyRkFFNUMsaUJBQWlCO2tCQUg3QixRQUFRO21CQUFDO29CQUNSLFNBQVMsRUFBRSxDQUFDLGtCQUFrQixFQUFFLHNCQUFzQixDQUFDO2lCQUN4RCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcblxuaW1wb3J0IHsgUmVDYXB0Y2hhVjNTZXJ2aWNlIH0gZnJvbSBcIi4vcmVjYXB0Y2hhLXYzLnNlcnZpY2VcIjtcbmltcG9ydCB7IFJlY2FwdGNoYUxvYWRlclNlcnZpY2UgfSBmcm9tIFwiLi9yZWNhcHRjaGEtbG9hZGVyLnNlcnZpY2VcIjtcblxuQE5nTW9kdWxlKHtcbiAgcHJvdmlkZXJzOiBbUmVDYXB0Y2hhVjNTZXJ2aWNlLCBSZWNhcHRjaGFMb2FkZXJTZXJ2aWNlXSxcbn0pXG5leHBvcnQgY2xhc3MgUmVjYXB0Y2hhVjNNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/recaptcha-v3.service.mjs

@@ -0,0 +1,106 @@
+import { Inject, Injectable } from "@angular/core";
+import { Subject } from "rxjs";
+import { RECAPTCHA_V3_SITE_KEY } from "./tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "./recaptcha-loader.service";
+/**
+ * The main service for working with reCAPTCHA v3 APIs.
+ *
+ * Use the `execute` method for executing a single action, and
+ * `onExecute` observable for listening to all actions at once.
+ */
+export class ReCaptchaV3Service {
+    constructor(zone, recaptchaLoader, siteKey) {
+        this.recaptchaLoader = recaptchaLoader;
+        this.zone = zone;
+        this.siteKey = siteKey;
+        this.init();
+    }
+    get onExecute() {
+        if (!this.onExecuteSubject) {
+            this.onExecuteSubject = new Subject();
+            this.onExecuteObservable = this.onExecuteSubject.asObservable();
+        }
+        return this.onExecuteObservable;
+    }
+    get onExecuteError() {
+        if (!this.onExecuteErrorSubject) {
+            this.onExecuteErrorSubject = new Subject();
+            this.onExecuteErrorObservable = this.onExecuteErrorSubject.asObservable();
+        }
+        return this.onExecuteErrorObservable;
+    }
+    /**
+     * Executes the provided `action` with reCAPTCHA v3 API.
+     * Use the emitted token value for verification purposes on the backend.
+     *
+     * For more information about reCAPTCHA v3 actions and tokens refer to the official documentation at
+     * https://developers.google.com/recaptcha/docs/v3.
+     *
+     * @param {string} action the action to execute
+     * @returns {Observable<string>} an `Observable` that will emit the reCAPTCHA v3 string `token` value whenever ready.
+     * The returned `Observable` completes immediately after emitting a value.
+     */
+    execute(action) {
+        const subject = new Subject();
+        if (!this.grecaptcha) {
+            if (!this.actionBacklog) {
+                this.actionBacklog = [];
+            }
+            this.actionBacklog.push([action, subject]);
+        }
+        else {
+            this.executeActionWithSubject(action, subject);
+        }
+        return subject.asObservable();
+    }
+    /** @internal */
+    executeActionWithSubject(action, subject) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const onError = (error) => {
+            this.zone.run(() => {
+                subject.error(error);
+                if (this.onExecuteErrorSubject) {
+                    // We don't know any better at this point, unfortunately, so have to resort to `any`
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    this.onExecuteErrorSubject.next({ action, error });
+                }
+            });
+        };
+        this.zone.runOutsideAngular(() => {
+            try {
+                this.grecaptcha.execute(this.siteKey, { action }).then((token) => {
+                    this.zone.run(() => {
+                        subject.next(token);
+                        subject.complete();
+                        if (this.onExecuteSubject) {
+                            this.onExecuteSubject.next({ action, token });
+                        }
+                    });
+                }, onError);
+            }
+            catch (e) {
+                onError(e);
+            }
+        });
+    }
+    /** @internal */
+    init() {
+        this.recaptchaLoader.ready.subscribe((value) => {
+            this.grecaptcha = value;
+            if (this.actionBacklog && this.actionBacklog.length > 0) {
+                this.actionBacklog.forEach(([action, subject]) => this.executeActionWithSubject(action, subject));
+                this.actionBacklog = undefined;
+            }
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: ReCaptchaV3Service, deps: [{ token: i0.NgZone }, { token: i1.RecaptchaLoaderService }, { token: RECAPTCHA_V3_SITE_KEY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: ReCaptchaV3Service }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: ReCaptchaV3Service, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: i1.RecaptchaLoaderService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RECAPTCHA_V3_SITE_KEY]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recaptcha-v3.service.js","sourceRoot":"","sources":["../../../../projects/ng-recaptcha/src/lib/recaptcha-v3.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AAE3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;;;AA4BjD;;;;;GAKG;AAEH,MAAM,OAAO,kBAAkB;IAmB7B,YACE,IAAY,EACL,eAAuC,EACf,OAAe;QADvC,oBAAe,GAAf,eAAe,CAAwB;QAG9C,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED,IAAW,SAAS;QAClB,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC3B,IAAI,CAAC,gBAAgB,GAAG,IAAI,OAAO,EAAiB,CAAC;YACrD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,CAAC,YAAY,EAAE,CAAC;QAClE,CAAC;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IAED,IAAW,cAAc;QACvB,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAChC,IAAI,CAAC,qBAAqB,GAAG,IAAI,OAAO,EAAsB,CAAC;YAC/D,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,qBAAqB,CAAC,YAAY,EAAE,CAAC;QAC5E,CAAC;QAED,OAAO,IAAI,CAAC,wBAAwB,CAAC;IACvC,CAAC;IAED;;;;;;;;;;OAUG;IACI,OAAO,CAAC,MAAc;QAC3B,MAAM,OAAO,GAAG,IAAI,OAAO,EAAU,CAAC;QACtC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;gBACxB,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;YAC1B,CAAC;YAED,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACjD,CAAC;QAED,OAAO,OAAO,CAAC,YAAY,EAAE,CAAC;IAChC,CAAC;IAED,gBAAgB;IACR,wBAAwB,CAAC,MAAc,EAAE,OAAwB;QACvE,8DAA8D;QAC9D,MAAM,OAAO,GAAG,CAAC,KAAU,EAAE,EAAE;YAC7B,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;gBACjB,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACrB,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;oBAC/B,oFAAoF;oBACpF,mEAAmE;oBACnE,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;gBACrD,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE;YAC/B,IAAI,CAAC;gBACH,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,KAAa,EAAE,EAAE;oBACvE,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;wBACjB,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBACpB,OAAO,CAAC,QAAQ,EAAE,CAAC;wBACnB,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;4BAC1B,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;wBAChD,CAAC;oBACH,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE,OAAO,CAAC,CAAC;YACd,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,CAAC,CAAC,CAAC;YACb,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,gBAAgB;IACR,IAAI;QACV,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YAC7C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YACxB,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;gBAClG,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;YACjC,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;8GAlHU,kBAAkB,8EAsBnB,qBAAqB;kHAtBpB,kBAAkB;;2FAAlB,kBAAkB;kBAD9B,UAAU;;0BAuBN,MAAM;2BAAC,qBAAqB","sourcesContent":["import { Inject, Injectable, NgZone } from \"@angular/core\";\nimport { Observable, Subject } from \"rxjs\";\n\nimport { RECAPTCHA_V3_SITE_KEY } from \"./tokens\";\nimport { RecaptchaLoaderService } from \"./recaptcha-loader.service\";\n\nexport interface OnExecuteData {\n  /**\n   * The name of the action that has been executed.\n   */\n  action: string;\n  /**\n   * The token that reCAPTCHA v3 provided when executing the action.\n   */\n  token: string;\n}\n\nexport interface OnExecuteErrorData {\n  /**\n   * The name of the action that has been executed.\n   */\n  action: string;\n  /**\n   * The error which was encountered\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  error: any;\n}\n\ntype ActionBacklogEntry = [string, Subject<string>];\n\n/**\n * The main service for working with reCAPTCHA v3 APIs.\n *\n * Use the `execute` method for executing a single action, and\n * `onExecute` observable for listening to all actions at once.\n */\n@Injectable()\nexport class ReCaptchaV3Service {\n  /** @internal */\n  private readonly siteKey: string;\n  /** @internal */\n  private readonly zone: NgZone;\n  /** @internal */\n  private actionBacklog: ActionBacklogEntry[] | undefined;\n  /** @internal */\n  private grecaptcha: ReCaptchaV2.ReCaptcha;\n\n  /** @internal */\n  private onExecuteSubject: Subject<OnExecuteData>;\n  /** @internal */\n  private onExecuteErrorSubject: Subject<OnExecuteErrorData>;\n  /** @internal */\n  private onExecuteObservable: Observable<OnExecuteData>;\n  /** @internal */\n  private onExecuteErrorObservable: Observable<OnExecuteErrorData>;\n\n  constructor(\n    zone: NgZone,\n    public recaptchaLoader: RecaptchaLoaderService,\n    @Inject(RECAPTCHA_V3_SITE_KEY) siteKey: string,\n  ) {\n    this.zone = zone;\n    this.siteKey = siteKey;\n\n    this.init();\n  }\n\n  public get onExecute(): Observable<OnExecuteData> {\n    if (!this.onExecuteSubject) {\n      this.onExecuteSubject = new Subject<OnExecuteData>();\n      this.onExecuteObservable = this.onExecuteSubject.asObservable();\n    }\n\n    return this.onExecuteObservable;\n  }\n\n  public get onExecuteError(): Observable<OnExecuteErrorData> {\n    if (!this.onExecuteErrorSubject) {\n      this.onExecuteErrorSubject = new Subject<OnExecuteErrorData>();\n      this.onExecuteErrorObservable = this.onExecuteErrorSubject.asObservable();\n    }\n\n    return this.onExecuteErrorObservable;\n  }\n\n  /**\n   * Executes the provided `action` with reCAPTCHA v3 API.\n   * Use the emitted token value for verification purposes on the backend.\n   *\n   * For more information about reCAPTCHA v3 actions and tokens refer to the official documentation at\n   * https://developers.google.com/recaptcha/docs/v3.\n   *\n   * @param {string} action the action to execute\n   * @returns {Observable<string>} an `Observable` that will emit the reCAPTCHA v3 string `token` value whenever ready.\n   * The returned `Observable` completes immediately after emitting a value.\n   */\n  public execute(action: string): Observable<string> {\n    const subject = new Subject<string>();\n    if (!this.grecaptcha) {\n      if (!this.actionBacklog) {\n        this.actionBacklog = [];\n      }\n\n      this.actionBacklog.push([action, subject]);\n    } else {\n      this.executeActionWithSubject(action, subject);\n    }\n\n    return subject.asObservable();\n  }\n\n  /** @internal */\n  private executeActionWithSubject(action: string, subject: Subject<string>): void {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const onError = (error: any) => {\n      this.zone.run(() => {\n        subject.error(error);\n        if (this.onExecuteErrorSubject) {\n          // We don't know any better at this point, unfortunately, so have to resort to `any`\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment\n          this.onExecuteErrorSubject.next({ action, error });\n        }\n      });\n    };\n\n    this.zone.runOutsideAngular(() => {\n      try {\n        this.grecaptcha.execute(this.siteKey, { action }).then((token: string) => {\n          this.zone.run(() => {\n            subject.next(token);\n            subject.complete();\n            if (this.onExecuteSubject) {\n              this.onExecuteSubject.next({ action, token });\n            }\n          });\n        }, onError);\n      } catch (e) {\n        onError(e);\n      }\n    });\n  }\n\n  /** @internal */\n  private init() {\n    this.recaptchaLoader.ready.subscribe((value) => {\n      this.grecaptcha = value;\n      if (this.actionBacklog && this.actionBacklog.length > 0) {\n        this.actionBacklog.forEach(([action, subject]) => this.executeActionWithSubject(action, subject));\n        this.actionBacklog = undefined;\n      }\n    });\n  }\n}\n"]}

package/esm2022/lib/recaptcha-value-accessor.directive.mjs

@@ -0,0 +1,68 @@
+import { Directive, forwardRef, HostListener } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import * as i0 from "@angular/core";
+import * as i1 from "./recaptcha.component";
+export class RecaptchaValueAccessorDirective {
+    constructor(host) {
+        this.host = host;
+        this.requiresControllerReset = false;
+    }
+    writeValue(value) {
+        if (!value) {
+            this.host.reset();
+        }
+        else {
+            // In this case, it is most likely that a form controller has requested to write a specific value into the component.
+            // This isn't really a supported case - reCAPTCHA values are single-use, and, in a sense, readonly.
+            // What this means is that the form controller has recaptcha control state of X, while reCAPTCHA itself can't "restore"
+            // to that state. In order to make form controller aware of this discrepancy, and to fix the said misalignment,
+            // we'll be telling the controller to "reset" the value back to null.
+            if (this.host.__unsafe_widgetValue !== value && Boolean(this.host.__unsafe_widgetValue) === false) {
+                this.requiresControllerReset = true;
+            }
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+        if (this.requiresControllerReset) {
+            this.requiresControllerReset = false;
+            this.onChange(null);
+        }
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    onResolve($event) {
+        if (this.onChange) {
+            this.onChange($event);
+        }
+        if (this.onTouched) {
+            this.onTouched();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaValueAccessorDirective, deps: [{ token: i1.RecaptchaComponent }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.0.1", type: RecaptchaValueAccessorDirective, selector: "re-captcha[formControlName],re-captcha[formControl],re-captcha[ngModel]", host: { listeners: { "resolved": "onResolve($event)" } }, providers: [
+            {
+                multi: true,
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => RecaptchaValueAccessorDirective),
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaValueAccessorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    providers: [
+                        {
+                            multi: true,
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => RecaptchaValueAccessorDirective),
+                        },
+                    ],
+                    selector: "re-captcha[formControlName],re-captcha[formControl],re-captcha[ngModel]",
+                }]
+        }], ctorParameters: () => [{ type: i1.RecaptchaComponent }], propDecorators: { onResolve: [{
+                type: HostListener,
+                args: ["resolved", ["$event"]]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/recaptcha.component.mjs

@@ -0,0 +1,171 @@
+import { Component, EventEmitter, HostBinding, Inject, Input, Optional, Output, } from "@angular/core";
+import { RECAPTCHA_SETTINGS } from "./tokens";
+import * as i0 from "@angular/core";
+import * as i1 from "./recaptcha-loader.service";
+let nextId = 0;
+export class RecaptchaComponent {
+    constructor(elementRef, loader, zone, settings) {
+        this.elementRef = elementRef;
+        this.loader = loader;
+        this.zone = zone;
+        this.id = `ngrecaptcha-${nextId++}`;
+        this.errorMode = "default";
+        this.resolved = new EventEmitter();
+        /**
+         * @deprecated `(error) output will be removed in the next major version. Use (errored) instead
+         */
+        // eslint-disable-next-line @angular-eslint/no-output-native
+        this.error = new EventEmitter();
+        this.errored = new EventEmitter();
+        if (settings) {
+            this.siteKey = settings.siteKey;
+            this.theme = settings.theme;
+            this.type = settings.type;
+            this.size = settings.size;
+            this.badge = settings.badge;
+        }
+    }
+    ngAfterViewInit() {
+        this.subscription = this.loader.ready.subscribe((grecaptcha) => {
+            if (grecaptcha != null && grecaptcha.render instanceof Function) {
+                this.grecaptcha = grecaptcha;
+                this.renderRecaptcha();
+            }
+        });
+    }
+    ngOnDestroy() {
+        // reset the captcha to ensure it does not leave anything behind
+        // after the component is no longer needed
+        this.grecaptchaReset();
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    /**
+     * Executes the invisible recaptcha.
+     * Does nothing if component's size is not set to "invisible".
+     */
+    execute() {
+        if (this.size !== "invisible") {
+            return;
+        }
+        if (this.widget != null) {
+            void this.grecaptcha.execute(this.widget);
+        }
+        else {
+            // delay execution of recaptcha until it actually renders
+            this.executeRequested = true;
+        }
+    }
+    reset() {
+        if (this.widget != null) {
+            if (this.grecaptcha.getResponse(this.widget)) {
+                // Only emit an event in case if something would actually change.
+                // That way we do not trigger "touching" of the control if someone does a "reset"
+                // on a non-resolved captcha.
+                this.resolved.emit(null);
+            }
+            this.grecaptchaReset();
+        }
+    }
+    /**
+     * ⚠️ Warning! Use this property at your own risk!
+     *
+     * While this member is `public`, it is not a part of the component's public API.
+     * The semantic versioning guarantees _will not be honored_! Thus, you might find that this property behavior changes in incompatible ways in minor or even patch releases.
+     * You are **strongly advised** against using this property.
+     * Instead, use more idiomatic ways to get reCAPTCHA value, such as `resolved` EventEmitter, or form-bound methods (ngModel, formControl, and the likes).å
+     */
+    get __unsafe_widgetValue() {
+        return this.widget != null ? this.grecaptcha.getResponse(this.widget) : null;
+    }
+    /** @internal */
+    expired() {
+        this.resolved.emit(null);
+    }
+    /** @internal */
+    onError(args) {
+        // eslint-disable-next-line deprecation/deprecation
+        this.error.emit(args);
+        this.errored.emit(args);
+    }
+    /** @internal */
+    captchaResponseCallback(response) {
+        this.resolved.emit(response);
+    }
+    /** @internal */
+    grecaptchaReset() {
+        if (this.widget != null) {
+            this.zone.runOutsideAngular(() => this.grecaptcha.reset(this.widget));
+        }
+    }
+    /** @internal */
+    renderRecaptcha() {
+        // This `any` can be removed after @types/grecaptcha get updated
+        const renderOptions = {
+            badge: this.badge,
+            callback: (response) => {
+                this.zone.run(() => this.captchaResponseCallback(response));
+            },
+            "expired-callback": () => {
+                this.zone.run(() => this.expired());
+            },
+            sitekey: this.siteKey,
+            size: this.size,
+            tabindex: this.tabIndex,
+            theme: this.theme,
+            type: this.type,
+        };
+        if (this.errorMode === "handled") {
+            renderOptions["error-callback"] = (...args) => {
+                this.zone.run(() => this.onError(args));
+            };
+        }
+        this.widget = this.grecaptcha.render(this.elementRef.nativeElement, renderOptions);
+        if (this.executeRequested === true) {
+            this.executeRequested = false;
+            this.execute();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaComponent, deps: [{ token: i0.ElementRef }, { token: i1.RecaptchaLoaderService }, { token: i0.NgZone }, { token: RECAPTCHA_SETTINGS, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.0.1", type: RecaptchaComponent, selector: "re-captcha", inputs: { id: "id", siteKey: "siteKey", theme: "theme", type: "type", size: "size", tabIndex: "tabIndex", badge: "badge", errorMode: "errorMode" }, outputs: { resolved: "resolved", error: "error", errored: "errored" }, host: { properties: { "attr.id": "this.id" } }, exportAs: ["reCaptcha"], ngImport: i0, template: ``, isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.1", ngImport: i0, type: RecaptchaComponent, decorators: [{
+            type: Component,
+            args: [{
+                    exportAs: "reCaptcha",
+                    selector: "re-captcha",
+                    template: ``,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.RecaptchaLoaderService }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RECAPTCHA_SETTINGS]
+                }] }], propDecorators: { id: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ["attr.id"]
+            }], siteKey: [{
+                type: Input
+            }], theme: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], tabIndex: [{
+                type: Input
+            }], badge: [{
+                type: Input
+            }], errorMode: [{
+                type: Input
+            }], resolved: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }], errored: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recaptcha.component.js","sourceRoot":"","sources":["../../../../projects/ng-recaptcha/src/lib/recaptcha.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Inject,\n  Input,\n  NgZone,\n  OnDestroy,\n  Optional,\n  Output,\n} from \"@angular/core\";\nimport { Subscription } from \"rxjs\";\n\nimport { RecaptchaLoaderService } from \"./recaptcha-loader.service\";\nimport { RecaptchaSettings } from \"./recaptcha-settings\";\nimport { RECAPTCHA_SETTINGS } from \"./tokens\";\n\nlet nextId = 0;\n\nexport type NeverUndefined<T> = T extends undefined ? never : T;\n\nexport type RecaptchaErrorParameters = Parameters<NeverUndefined<ReCaptchaV2.Parameters[\"error-callback\"]>>;\n\n@Component({\n  exportAs: \"reCaptcha\",\n  selector: \"re-captcha\",\n  template: ``,\n})\nexport class RecaptchaComponent implements AfterViewInit, OnDestroy {\n  @Input()\n  @HostBinding(\"attr.id\")\n  public id = `ngrecaptcha-${nextId++}`;\n\n  @Input() public siteKey?: string;\n  @Input() public theme?: ReCaptchaV2.Theme;\n  @Input() public type?: ReCaptchaV2.Type;\n  @Input() public size?: ReCaptchaV2.Size;\n  @Input() public tabIndex?: number;\n  @Input() public badge?: ReCaptchaV2.Badge;\n  @Input() public errorMode: \"handled\" | \"default\" = \"default\";\n\n  @Output() public resolved = new EventEmitter<string | null>();\n  /**\n   * @deprecated `(error) output will be removed in the next major version. Use (errored) instead\n   */\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  @Output() public error = new EventEmitter<RecaptchaErrorParameters>();\n  @Output() public errored = new EventEmitter<RecaptchaErrorParameters>();\n\n  /** @internal */\n  private subscription: Subscription;\n  /** @internal */\n  private widget: number;\n  /** @internal */\n  private grecaptcha: ReCaptchaV2.ReCaptcha;\n  /** @internal */\n  private executeRequested: boolean;\n\n  constructor(\n    private elementRef: ElementRef<HTMLElement>,\n    private loader: RecaptchaLoaderService,\n    private zone: NgZone,\n    @Optional() @Inject(RECAPTCHA_SETTINGS) settings?: RecaptchaSettings,\n  ) {\n    if (settings) {\n      this.siteKey = settings.siteKey;\n      this.theme = settings.theme;\n      this.type = settings.type;\n      this.size = settings.size;\n      this.badge = settings.badge;\n    }\n  }\n\n  public ngAfterViewInit(): void {\n    this.subscription = this.loader.ready.subscribe((grecaptcha: ReCaptchaV2.ReCaptcha) => {\n      if (grecaptcha != null && grecaptcha.render instanceof Function) {\n        this.grecaptcha = grecaptcha;\n        this.renderRecaptcha();\n      }\n    });\n  }\n\n  public ngOnDestroy(): void {\n    // reset the captcha to ensure it does not leave anything behind\n    // after the component is no longer needed\n    this.grecaptchaReset();\n    if (this.subscription) {\n      this.subscription.unsubscribe();\n    }\n  }\n\n  /**\n   * Executes the invisible recaptcha.\n   * Does nothing if component's size is not set to \"invisible\".\n   */\n  public execute(): void {\n    if (this.size !== \"invisible\") {\n      return;\n    }\n\n    if (this.widget != null) {\n      void this.grecaptcha.execute(this.widget);\n    } else {\n      // delay execution of recaptcha until it actually renders\n      this.executeRequested = true;\n    }\n  }\n\n  public reset(): void {\n    if (this.widget != null) {\n      if (this.grecaptcha.getResponse(this.widget)) {\n        // Only emit an event in case if something would actually change.\n        // That way we do not trigger \"touching\" of the control if someone does a \"reset\"\n        // on a non-resolved captcha.\n        this.resolved.emit(null);\n      }\n\n      this.grecaptchaReset();\n    }\n  }\n\n  /**\n   * ⚠️ Warning! Use this property at your own risk!\n   *\n   * While this member is `public`, it is not a part of the component's public API.\n   * The semantic versioning guarantees _will not be honored_! Thus, you might find that this property behavior changes in incompatible ways in minor or even patch releases.\n   * You are **strongly advised** against using this property.\n   * Instead, use more idiomatic ways to get reCAPTCHA value, such as `resolved` EventEmitter, or form-bound methods (ngModel, formControl, and the likes).å\n   */\n  public get __unsafe_widgetValue(): string | null {\n    return this.widget != null ? this.grecaptcha.getResponse(this.widget) : null;\n  }\n\n  /** @internal */\n  private expired() {\n    this.resolved.emit(null);\n  }\n\n  /** @internal */\n  private onError(args: RecaptchaErrorParameters) {\n    // eslint-disable-next-line deprecation/deprecation\n    this.error.emit(args);\n    this.errored.emit(args);\n  }\n\n  /** @internal */\n  private captchaResponseCallback(response: string) {\n    this.resolved.emit(response);\n  }\n\n  /** @internal */\n  private grecaptchaReset() {\n    if (this.widget != null) {\n      this.zone.runOutsideAngular(() => this.grecaptcha.reset(this.widget));\n    }\n  }\n\n  /** @internal */\n  private renderRecaptcha() {\n    // This `any` can be removed after @types/grecaptcha get updated\n    const renderOptions: ReCaptchaV2.Parameters = {\n      badge: this.badge,\n      callback: (response: string) => {\n        this.zone.run(() => this.captchaResponseCallback(response));\n      },\n      \"expired-callback\": () => {\n        this.zone.run(() => this.expired());\n      },\n      sitekey: this.siteKey,\n      size: this.size,\n      tabindex: this.tabIndex,\n      theme: this.theme,\n      type: this.type,\n    };\n\n    if (this.errorMode === \"handled\") {\n      renderOptions[\"error-callback\"] = (...args: RecaptchaErrorParameters) => {\n        this.zone.run(() => this.onError(args));\n      };\n    }\n\n    this.widget = this.grecaptcha.render(this.elementRef.nativeElement, renderOptions);\n\n    if (this.executeRequested === true) {\n      this.executeRequested = false;\n      this.execute();\n    }\n  }\n}\n"]}