@xsolla/payment-client-core 0.0.4 → 0.0.6

package/esm2020/lib/core/device-finger-print/device-finger-print-components.interface.mjs

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

package/esm2020/lib/core/device-finger-print/device-finger-print.service.mjs

@@ -0,0 +1,167 @@
+import { Inject, Injectable } from '@angular/core';
+import { windowToken } from '../window.token';
+import { TerminalError } from '../exceptions-handling/errors/terminal-error.class';
+import { DefaultTerminalError } from '../exceptions-handling/errors/default-terminal-error.class';
+import { lastValueFrom } from 'rxjs';
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+import * as i1 from "../http/secure-api/secure-api.service";
+import * as i2 from "../settings/settings.service";
+export class DeviceFingerPrintService {
+    constructor(secureApi, settingsService, window) {
+        this.secureApi = secureApi;
+        this.settingsService = settingsService;
+        this.window = window;
+        this.apiRoute = 'dfp';
+        this.fingerprintApiUrl = 'https://afs.xsolla.com/dfp/api/v1/';
+    }
+    async init() {
+        if (!this.settingsService.isInitialized) {
+            return;
+        }
+        this.fingerprintJs = await this.loadFingerprintJs();
+        this.hash = await this.buildHash();
+        this.antifraudFingerprintLibrary =
+            await this.loadAntifraudFingerprintLibrary();
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async getHash() {
+        return this.hash;
+    }
+    async loadFingerprintJs() {
+        const { default: library, murmurX64Hash128: getHash } = await import('@fingerprintjs/fingerprintjs');
+        return { library, getHash };
+    }
+    async loadAntifraudFingerprintLibrary() {
+        const library = await import('@xsolla/antifraud-fingerprint');
+        return library.default;
+    }
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async makeAntifraudFingerprint() {
+        if (!this.settingsService.token) {
+            return null;
+        }
+        const antifraudFingerprint = this.antifraudFingerprintLibrary;
+        try {
+            return new antifraudFingerprint({
+                api: {
+                    url: this.fingerprintApiUrl,
+                    token: this.settingsService.token,
+                    timeout: 3000,
+                },
+                retry: {
+                    num: 1,
+                    timeout: 500,
+                },
+            });
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     *Загружаем библиотеку, генерируем данные,
+     *хешируем с помощью BASE64 и отправляем на бэкенд,
+     *в ответ получаем dfp_hash.
+     **/
+    async buildHash() {
+        const fingerPrintData = await this.generate();
+        const hash = await this.send(fingerPrintData).catch(() => {
+            return null;
+        });
+        return JSON.stringify(hash);
+    }
+    /**
+     *Новая версия библиотеки содержит не все компоненты, некоторые приходится имплементировать самостоятельно
+     **/
+    getHasLiedResolution() {
+        const { screen } = this.window;
+        return (screen.width < screen.availWidth || screen.height < screen.availHeight);
+    }
+    /**
+     *Бэкенд заточен под конкретные поля, которые необходимо смапить.
+     **/
+    getComponents(components) {
+        return {
+            user_agent: navigator.userAgent,
+            language: components.languages.value?.shift()?.shift() ?? '',
+            color_depth: components.colorDepth.value,
+            device_memory: components.deviceMemory.value,
+            hardware_concurrency: components.hardwareConcurrency.value,
+            resolution: components.screenResolution.value,
+            available_resolution: components.screenResolution.value,
+            timezone_offset: new Date().getTimezoneOffset(),
+            session_storage: components.sessionStorage.value ? 1 : 0,
+            local_storage: components.localStorage.value ? 1 : 0,
+            indexed_db: components.indexedDB.value ? 1 : 0,
+            open_database: components.openDatabase.value ? 1 : 0,
+            navigator_platform: components.platform.value,
+            regular_plugins: components.plugins.value?.map((plugin) => plugin.name) ?? [],
+            canvas: components.canvas.value?.text,
+            webgl: components.canvas.value?.text,
+            webgl_vendor: components.vendor.value,
+            has_lied_resolution: this.getHasLiedResolution(),
+            touch_support: Object.values(components.touchSupport.value ?? {}),
+            js_fonts: components.fonts.value,
+        };
+    }
+    /**
+     * Получаем данные dfp с помощью FingerprintJS, мапим необходимые поля, добавляем хэш
+     **/
+    async generate() {
+        const { library, getHash } = this.fingerprintJs;
+        const fingerprint = await library.load();
+        const commonFingerPrintData = await fingerprint.get();
+        const fingerPrintData = this.getComponents(commonFingerPrintData.components);
+        fingerPrintData.hash = getHash(JSON.stringify(fingerPrintData));
+        return fingerPrintData;
+    }
+    /**
+     * Отправка dfp на сервер, в ответ получаем dfp_hash
+     **/
+    async send(fingerPrintData) {
+        const token = this.settingsService.token;
+        if (token === null) {
+            throw new DefaultTerminalError();
+        }
+        const requestBody = {
+            access_token: token,
+            'dfp[200]': '',
+        };
+        requestBody['dfp[200]'] = btoa(encodeURIComponent(JSON.stringify(fingerPrintData)));
+        return lastValueFrom(this.secureApi.post(this.apiRoute, new URLSearchParams(requestBody), {
+            headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+            responseType: 'json',
+        }))
+            .then((response) => {
+            return response.dfp_hash;
+        })
+            .then(async (hash) => {
+            const fingerprint = await this.makeAntifraudFingerprint();
+            if (!fingerprint) {
+                return null;
+            }
+            await fingerprint
+                ?.dispatch(hash['200'])
+                .catch((err) => console.log(err));
+            const afsHash = await fingerprint.hash();
+            return { '301': afsHash, ...hash };
+        })
+            .catch((error) => {
+            const response = error.getHttpErrorData().response;
+            throw new TerminalError(response.data?.errors[0]?.message ?? '', response.data?.errors[0]?.support_code ?? '');
+        });
+    }
+}
+DeviceFingerPrintService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, deps: [{ token: i1.SecureApiClient }, { token: i2.SettingsService }, { token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable });
+DeviceFingerPrintService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: DeviceFingerPrintService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SecureApiClient }, { type: i2.SettingsService }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"device-finger-print.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/device-finger-print/device-finger-print.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { FingerprintJs } from './fingerprint-js.interface';\nimport type XsollaAntifraudFingerprint from '@xsolla/antifraud-fingerprint';\nimport { SecureApiClient } from '../http/secure-api/secure-api.service';\nimport { SettingsService } from '../settings/settings.service';\nimport { windowToken } from '../window.token';\nimport { ExtendedWindow } from '../extended-window.interface';\n\nimport { Hash } from './hash.type';\nimport { TerminalError } from '../exceptions-handling/errors/terminal-error.class';\nimport { DefaultTerminalError } from '../exceptions-handling/errors/default-terminal-error.class';\nimport {\n  Agent,\n  GetResult,\n  sources,\n  SourcesToComponents,\n} from '@fingerprintjs/fingerprintjs';\nimport { DeviceFingerPrintComponents } from './device-finger-print-components.interface';\nimport { lastValueFrom } from 'rxjs';\nimport { HttpHeaders } from '@angular/common/http';\nimport { HttpError } from '../exceptions-handling/errors/http-error.class';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class DeviceFingerPrintService {\n  private hash!: string;\n  private readonly apiRoute = 'dfp';\n  private fingerprintJs!: FingerprintJs;\n  private antifraudFingerprintLibrary!: typeof XsollaAntifraudFingerprint;\n\n  private readonly fingerprintApiUrl = 'https://afs.xsolla.com/dfp/api/v1/';\n\n  public constructor(\n    private readonly secureApi: SecureApiClient,\n    private readonly settingsService: SettingsService,\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow\n  ) {}\n\n  public async init(): Promise<void> {\n    if (!this.settingsService.isInitialized) {\n      return;\n    }\n    this.fingerprintJs = await this.loadFingerprintJs();\n    this.hash = await this.buildHash();\n    this.antifraudFingerprintLibrary =\n      await this.loadAntifraudFingerprintLibrary();\n  }\n\n  // eslint-disable-next-line @typescript-eslint/require-await\n  public async getHash(): Promise<string> {\n    return this.hash;\n  }\n\n  private async loadFingerprintJs(): Promise<FingerprintJs> {\n    const { default: library, murmurX64Hash128: getHash } = await import(\n      '@fingerprintjs/fingerprintjs'\n    );\n\n    return { library, getHash };\n  }\n\n  private async loadAntifraudFingerprintLibrary(): Promise<\n    typeof XsollaAntifraudFingerprint\n  > {\n    const library: { default: unknown } = await import(\n      '@xsolla/antifraud-fingerprint'\n    );\n\n    return library.default as typeof XsollaAntifraudFingerprint;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/require-await\n  private async makeAntifraudFingerprint(): Promise<XsollaAntifraudFingerprint | null> {\n    if (!this.settingsService.token) {\n      return null;\n    }\n\n    const antifraudFingerprint: typeof XsollaAntifraudFingerprint =\n      this.antifraudFingerprintLibrary;\n\n    try {\n      return new antifraudFingerprint({\n        api: {\n          url: this.fingerprintApiUrl,\n          token: this.settingsService.token,\n          timeout: 3000,\n        },\n        retry: {\n          num: 1,\n          timeout: 500,\n        },\n      });\n    } catch (error: unknown) {\n      return null;\n    }\n  }\n\n  /**\n   *Загружаем библиотеку, генерируем данные,\n   *хешируем с помощью BASE64 и отправляем на бэкенд,\n   *в ответ получаем dfp_hash.\n   **/\n  private async buildHash(): Promise<string> {\n    const fingerPrintData = await this.generate();\n    const hash: Hash = await this.send(fingerPrintData).catch(() => {\n      return null;\n    });\n\n    return JSON.stringify(hash);\n  }\n\n  /**\n   *Новая версия библиотеки содержит не все компоненты, некоторые приходится имплементировать самостоятельно\n   **/\n  private getHasLiedResolution(): boolean {\n    const { screen } = this.window;\n    return (\n      screen.width < screen.availWidth || screen.height < screen.availHeight\n    );\n  }\n\n  /**\n   *Бэкенд заточен под конкретные поля, которые необходимо смапить.\n   **/\n  private getComponents(\n    components: SourcesToComponents<typeof sources>\n  ): DeviceFingerPrintComponents {\n    return {\n      user_agent: navigator.userAgent,\n      language: components.languages.value?.shift()?.shift() ?? '',\n      color_depth: components.colorDepth.value,\n      device_memory: components.deviceMemory.value,\n      hardware_concurrency: components.hardwareConcurrency.value,\n      resolution: components.screenResolution.value,\n      available_resolution: components.screenResolution.value,\n      timezone_offset: new Date().getTimezoneOffset(),\n      session_storage: components.sessionStorage.value ? 1 : 0,\n      local_storage: components.localStorage.value ? 1 : 0,\n      indexed_db: components.indexedDB.value ? 1 : 0,\n      open_database: components.openDatabase.value ? 1 : 0,\n      navigator_platform: components.platform.value,\n      regular_plugins:\n        components.plugins.value?.map((plugin) => plugin.name) ?? [],\n      canvas: components.canvas.value?.text,\n      webgl: components.canvas.value?.text,\n      webgl_vendor: components.vendor.value,\n      has_lied_resolution: this.getHasLiedResolution(),\n      touch_support: Object.values(components.touchSupport.value ?? {}),\n      js_fonts: components.fonts.value,\n    };\n  }\n\n  /**\n   * Получаем данные dfp с помощью FingerprintJS, мапим необходимые поля, добавляем хэш\n   **/\n  private async generate(): Promise<DeviceFingerPrintComponents> {\n    const { library, getHash } = this.fingerprintJs;\n    const fingerprint: Agent = await library.load();\n    const commonFingerPrintData: GetResult = await fingerprint.get();\n\n    const fingerPrintData: DeviceFingerPrintComponents = this.getComponents(\n      commonFingerPrintData.components\n    );\n    fingerPrintData.hash = getHash(JSON.stringify(fingerPrintData));\n    return fingerPrintData;\n  }\n\n  /**\n   * Отправка dfp на сервер, в ответ получаем dfp_hash\n   **/\n  private async send(\n    fingerPrintData: DeviceFingerPrintComponents\n  ): Promise<{ '200': string } | null> {\n    const token = this.settingsService.token;\n\n    if (token === null) {\n      throw new DefaultTerminalError();\n    }\n\n    const requestBody: { access_token: string; 'dfp[200]': string } = {\n      access_token: token,\n      'dfp[200]': '',\n    };\n\n    requestBody['dfp[200]'] = btoa(\n      encodeURIComponent(JSON.stringify(fingerPrintData))\n    );\n    return lastValueFrom(\n      this.secureApi.post<{ dfp_hash: { '200': string }; user_id?: string }>(\n        this.apiRoute,\n        new URLSearchParams(\n          requestBody as unknown as { [key: string]: string }\n        ),\n        {\n          headers: new HttpHeaders().set(\n            'Content-Type',\n            'application/x-www-form-urlencoded; charset=utf-8'\n          ),\n          responseType: 'json',\n        }\n      )\n    )\n      .then((response: { dfp_hash: { '200': string }; user_id?: string }) => {\n        return response.dfp_hash;\n      })\n      .then(async (hash: { '200': string }) => {\n        const fingerprint: XsollaAntifraudFingerprint | null =\n          await this.makeAntifraudFingerprint();\n\n        if (!fingerprint) {\n          return null;\n        }\n\n        await fingerprint\n          ?.dispatch(hash['200'])\n          .catch((err) => console.log(err));\n\n        const afsHash = await fingerprint.hash();\n\n        return { '301': afsHash, ...hash };\n      })\n      .catch((error: HttpError) => {\n        const response = error.getHttpErrorData().response;\n\n        throw new TerminalError(\n          response.data?.errors[0]?.message ?? '',\n          response.data?.errors[0]?.support_code ?? ''\n        );\n      });\n  }\n}\n"]}

package/esm2020/lib/core/device-finger-print/fingerprint-js.interface.mjs

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

package/esm2020/lib/core/device-finger-print/hash.type.mjs

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

package/esm2020/lib/core/exceptions-handling/elk/additional-info.interface.mjs

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

package/esm2020/lib/core/exceptions-handling/elk/elk-logger.service.mjs

@@ -0,0 +1,120 @@
+import { firstValueFrom } from 'rxjs';
+import { Inject, Injectable, isDevMode, } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { windowToken } from '../../window.token';
+import { TaggedError } from '../errors/tagged-error.class';
+import { ErrorTags } from '../errors/elk-error-types.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../settings/settings.service";
+import * as i2 from "@angular/common/http";
+export class ElkLoggerService {
+    constructor(window, settingsService, http, ngZone) {
+        this.window = window;
+        this.settingsService = settingsService;
+        this.http = http;
+        this.ngZone = ngZone;
+        this.vendors = new RegExp('node_modules\\/(@angular|zone).*.js$');
+        this.stackTrace = this.loadStackTrace();
+    }
+    handleError(error) {
+        this.ngZone.runOutsideAngular(() => {
+            if (isDevMode()) {
+                console.error(error);
+                return;
+            }
+            this.parseError(error).catch(console.log);
+        });
+    }
+    log(message, tags, extra) {
+        const logTags = [ErrorTags.HEADLESS_UI, ...tags];
+        if (isDevMode()) {
+            console.log(message, tags);
+            return;
+        }
+        const logMessage = {
+            additionalInfo: this.getAdditionalInfo(),
+            extra,
+            message,
+        };
+        this.sendLog(logMessage, logTags);
+    }
+    async parseError(error) {
+        const errorObj = error instanceof TaggedError
+            ? error
+            : new TaggedError(error.message || error.toString());
+        errorObj.trace = await this.getErrorTrace(errorObj);
+        errorObj.additionalInfo = this.getAdditionalInfo();
+        const { tags } = errorObj;
+        const cleanError = this.removeErrorMetaFields(errorObj);
+        this.sendLog(cleanError, tags);
+        return errorObj;
+    }
+    async loadStackTrace() {
+        const library = await import('stacktrace-js');
+        return library.default;
+    }
+    async getErrorTrace(error) {
+        const stackTrace = await this.stackTrace;
+        const stackFramesArr = await stackTrace.fromError(error);
+        const filteredFramesArr = stackFramesArr.filter(({ fileName }) => fileName && !this.vendors.test(fileName));
+        return filteredFramesArr
+            .map((stackFrame) => stackFrame.toString())
+            .join('\n');
+    }
+    getAdditionalInfo() {
+        const extractUrlHost = (url) => url.replace(/^https?:\/\/([^/?#]+).*$/i, '$1');
+        return {
+            location: {
+                url: this.window.location.href,
+            },
+            project: {
+                id: this.settingsService.project.id,
+            },
+            referrer: {
+                url: this.window.document.referrer,
+            },
+            viewport: {
+                width: this.window.document.documentElement.clientWidth,
+                height: this.window.document.documentElement.clientHeight,
+            },
+            cdn_address: this.settingsService.settings.cdnUrl
+                ? extractUrlHost(this.settingsService.settings.cdnUrl)
+                : 'none',
+            country: this.settingsService.user.country.value,
+            local: this.settingsService.user.country.localized_name,
+        };
+    }
+    removeErrorMetaFields(error) {
+        const metaPropList = [
+            'parentTag',
+            'childTag',
+            'RESTRICTED_KEYS_REGEXP',
+            'tags',
+        ];
+        Object.keys(error).forEach((key) => {
+            if (metaPropList.includes(key))
+                delete error[key];
+        });
+        // implementing own 'message' property from prototype
+        return { ...error, message: error.message };
+    }
+    sendLog(message, tags) {
+        const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;
+        firstValueFrom(this.http.post(url, message, {
+            headers: new HttpHeaders().set('Content-Type', 'text/plain'),
+            responseType: 'text',
+        })).catch((err) => console.error('Elk Logger: request error', err));
+    }
+}
+ElkLoggerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, deps: [{ token: windowToken }, { token: i1.SettingsService }, { token: i2.HttpClient }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+ElkLoggerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: ElkLoggerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.SettingsService }, { type: i2.HttpClient }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"elk-logger.service.js","sourceRoot":"","sources":["../../../../../../../packages/payment-client-core/src/lib/core/exceptions-handling/elk/elk-logger.service.ts"],"names":[],"mappings":"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","sourcesContent":["import type StackTrace from 'stacktrace-js';\nimport { firstValueFrom } from 'rxjs';\nimport {\n  ErrorHandler,\n  Inject,\n  Injectable,\n  isDevMode,\n  NgZone,\n} from '@angular/core';\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\nimport { windowToken } from '../../window.token';\nimport { SettingsService } from '../../settings/settings.service';\nimport { ExtendedWindow } from '../../extended-window.interface';\nimport { TaggedError } from '../errors/tagged-error.class';\nimport { ErrorTags } from '../errors/elk-error-types.enum';\nimport { AdditionalInfo } from './additional-info.interface';\nimport { ErrorWithoutMetaFields } from './error-without-meta-fields.interface';\nimport { LogMessage } from './log-message.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class ElkLoggerService implements ErrorHandler {\n  private readonly stackTrace: Promise<typeof StackTrace>;\n  private readonly vendors: RegExp = new RegExp(\n    'node_modules\\\\/(@angular|zone).*.js$'\n  );\n\n  public constructor(\n    @Inject(windowToken) private readonly window: ExtendedWindow,\n    private readonly settingsService: SettingsService,\n    private readonly http: HttpClient,\n    private readonly ngZone: NgZone\n  ) {\n    this.stackTrace = this.loadStackTrace();\n  }\n\n  public handleError(error: Error): void {\n    this.ngZone.runOutsideAngular(() => {\n      if (isDevMode()) {\n        console.error(error);\n        return;\n      }\n\n      this.parseError(error).catch(console.log);\n    });\n  }\n\n  public log(\n    message: string,\n    tags: ErrorTags[],\n    extra?: { [key: string]: unknown }\n  ): void {\n    const logTags = [ErrorTags.HEADLESS_UI, ...tags];\n\n    if (isDevMode()) {\n      console.log(message, tags);\n      return;\n    }\n\n    const logMessage: LogMessage = {\n      additionalInfo: this.getAdditionalInfo(),\n      extra,\n      message,\n    };\n\n    this.sendLog(logMessage, logTags);\n  }\n\n  private async parseError(error: Error): Promise<TaggedError> {\n    const errorObj =\n      error instanceof TaggedError\n        ? error\n        : new TaggedError(error.message || error.toString());\n\n    errorObj.trace = await this.getErrorTrace(errorObj);\n    errorObj.additionalInfo = this.getAdditionalInfo();\n\n    const { tags } = errorObj;\n\n    const cleanError = this.removeErrorMetaFields(errorObj);\n\n    this.sendLog(cleanError, tags);\n    return errorObj;\n  }\n\n  private async loadStackTrace(): Promise<typeof StackTrace> {\n    const library = await import('stacktrace-js');\n    return library.default;\n  }\n\n  private async getErrorTrace(error: Error): Promise<string> {\n    const stackTrace = await this.stackTrace;\n\n    const stackFramesArr = await stackTrace.fromError(error);\n\n    const filteredFramesArr = stackFramesArr.filter(\n      ({ fileName }) => fileName && !this.vendors.test(fileName)\n    );\n\n    return filteredFramesArr\n      .map((stackFrame) => stackFrame.toString())\n      .join('\\n');\n  }\n\n  private getAdditionalInfo(): AdditionalInfo {\n    const extractUrlHost = (url: string): string =>\n      url.replace(/^https?:\\/\\/([^/?#]+).*$/i, '$1');\n\n    return {\n      location: {\n        url: this.window.location.href,\n      },\n      project: {\n        id: this.settingsService.project.id,\n      },\n      referrer: {\n        url: this.window.document.referrer,\n      },\n      viewport: {\n        width: this.window.document.documentElement.clientWidth,\n        height: this.window.document.documentElement.clientHeight,\n      },\n      cdn_address: this.settingsService.settings.cdnUrl\n        ? extractUrlHost(this.settingsService.settings.cdnUrl)\n        : 'none',\n      country: this.settingsService.user.country.value,\n      local: this.settingsService.user.country.localized_name,\n    };\n  }\n\n  private removeErrorMetaFields(error: TaggedError): ErrorWithoutMetaFields {\n    const metaPropList = [\n      'parentTag',\n      'childTag',\n      'RESTRICTED_KEYS_REGEXP',\n      'tags',\n    ];\n\n    Object.keys(error).forEach((key) => {\n      if (metaPropList.includes(key)) delete error[key as keyof TaggedError];\n    });\n\n    // implementing own 'message' property from prototype\n    return { ...error, message: error.message };\n  }\n\n  private sendLog(\n    message: ErrorWithoutMetaFields | LogMessage,\n    tags: ErrorTags[]\n  ): void {\n    const url = `https://logs-01.xsolla.com/tag/${tags.join(',')}`;\n\n    firstValueFrom(\n      this.http.post(url, message, {\n        headers: new HttpHeaders().set('Content-Type', 'text/plain'),\n        responseType: 'text',\n      })\n    ).catch((err) => console.error('Elk Logger: request error', err));\n  }\n}\n"]}

package/esm2020/lib/core/exceptions-handling/elk/error-without-meta-fields.interface.mjs

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

package/esm2020/lib/core/exceptions-handling/elk/log-message.interface.mjs

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

package/esm2020/lib/core/exceptions-handling/errors/default-terminal-error.class.mjs

@@ -0,0 +1,8 @@
+import { TerminalError } from './terminal-error.class';
+export class DefaultTerminalError extends TerminalError {
+    constructor() {
+        const message = `It's not you, it's us, but we can help. Please contact our customer support.`;
+        super(message, '1000-0002');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdC10ZXJtaW5hbC1lcnJvci5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3BheW1lbnQtY2xpZW50LWNvcmUvc3JjL2xpYi9jb3JlL2V4Y2VwdGlvbnMtaGFuZGxpbmcvZXJyb3JzL2RlZmF1bHQtdGVybWluYWwtZXJyb3IuY2xhc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXZELE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxhQUFhO0lBQ3JEO1FBQ0UsTUFBTSxPQUFPLEdBQUcsOEVBQThFLENBQUM7UUFDL0YsS0FBSyxDQUFDLE9BQU8sRUFBRSxXQUFXLENBQUMsQ0FBQztJQUM5QixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUZXJtaW5hbEVycm9yIH0gZnJvbSAnLi90ZXJtaW5hbC1lcnJvci5jbGFzcyc7XG5cbmV4cG9ydCBjbGFzcyBEZWZhdWx0VGVybWluYWxFcnJvciBleHRlbmRzIFRlcm1pbmFsRXJyb3Ige1xuICBwdWJsaWMgY29uc3RydWN0b3IoKSB7XG4gICAgY29uc3QgbWVzc2FnZSA9IGBJdCdzIG5vdCB5b3UsIGl0J3MgdXMsIGJ1dCB3ZSBjYW4gaGVscC4gUGxlYXNlIGNvbnRhY3Qgb3VyIGN1c3RvbWVyIHN1cHBvcnQuYDtcbiAgICBzdXBlcihtZXNzYWdlLCAnMTAwMC0wMDAyJyk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/core/exceptions-handling/errors/elk-error-types.enum.mjs

@@ -0,0 +1,13 @@
+export var ErrorTags;
+(function (ErrorTags) {
+    ErrorTags["APP"] = "appError";
+    ErrorTags["HTTP"] = "httpError";
+    ErrorTags["JS"] = "jsError";
+    ErrorTags["WS"] = "webSocket";
+    ErrorTags["ENCRYPT"] = "encrypt";
+    ErrorTags["APPLEPAY"] = "applepay";
+    ErrorTags["HEADLESS_UI"] = "headlessUi";
+    ErrorTags["GOOGLEPAY"] = "googlepay";
+    ErrorTags["PAYTM"] = "paytm";
+})(ErrorTags || (ErrorTags = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxrLWVycm9yLXR5cGVzLmVudW0uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9leGNlcHRpb25zLWhhbmRsaW5nL2Vycm9ycy9lbGstZXJyb3ItdHlwZXMuZW51bS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQU4sSUFBWSxTQVVYO0FBVkQsV0FBWSxTQUFTO0lBQ25CLDZCQUFnQixDQUFBO0lBQ2hCLCtCQUFrQixDQUFBO0lBQ2xCLDJCQUFjLENBQUE7SUFDZCw2QkFBZ0IsQ0FBQTtJQUNoQixnQ0FBbUIsQ0FBQTtJQUNuQixrQ0FBcUIsQ0FBQTtJQUNyQix1Q0FBMEIsQ0FBQTtJQUMxQixvQ0FBdUIsQ0FBQTtJQUN2Qiw0QkFBZSxDQUFBO0FBQ2pCLENBQUMsRUFWVyxTQUFTLEtBQVQsU0FBUyxRQVVwQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBlbnVtIEVycm9yVGFncyB7XG4gIEFQUCA9ICdhcHBFcnJvcicsXG4gIEhUVFAgPSAnaHR0cEVycm9yJyxcbiAgSlMgPSAnanNFcnJvcicsXG4gIFdTID0gJ3dlYlNvY2tldCcsXG4gIEVOQ1JZUFQgPSAnZW5jcnlwdCcsXG4gIEFQUExFUEFZID0gJ2FwcGxlcGF5JyxcbiAgSEVBRExFU1NfVUkgPSAnaGVhZGxlc3NVaScsXG4gIEdPT0dMRVBBWSA9ICdnb29nbGVwYXknLFxuICBQQVlUTSA9ICdwYXl0bScsXG59XG4iXX0=

package/esm2020/lib/core/exceptions-handling/errors/tagged-error.class.mjs

@@ -0,0 +1,16 @@
+import { ErrorTags } from './elk-error-types.enum';
+export class TaggedError extends Error {
+    constructor(message, tags) {
+        super(message);
+        this.tags = [];
+        this.parentTag = ErrorTags.HEADLESS_UI;
+        this.tags = this.childTag
+            ? [this.parentTag, this.childTag]
+            : [this.parentTag];
+        if (tags) {
+            const newTags = tags.filter((t, i, arr) => !this.tags.includes(t) && arr.indexOf(t) == i);
+            this.tags = [...this.tags, ...newTags];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/exceptions-handling/errors/terminal-error.class.mjs

@@ -0,0 +1,8 @@
+import { AppError } from './app-error.class';
+export class TerminalError extends AppError {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVybWluYWwtZXJyb3IuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9leGNlcHRpb25zLWhhbmRsaW5nL2Vycm9ycy90ZXJtaW5hbC1lcnJvci5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFN0MsTUFBTSxPQUFPLGFBQWMsU0FBUSxRQUFRO0lBR3pDLFlBQW1CLE9BQWUsRUFBRSxJQUFZO1FBQzlDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUVmLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDO0lBQ25CLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFwcEVycm9yIH0gZnJvbSAnLi9hcHAtZXJyb3IuY2xhc3MnO1xuXG5leHBvcnQgY2xhc3MgVGVybWluYWxFcnJvciBleHRlbmRzIEFwcEVycm9yIHtcbiAgcHVibGljIGNvZGUhOiBzdHJpbmc7XG5cbiAgcHVibGljIGNvbnN0cnVjdG9yKG1lc3NhZ2U6IHN0cmluZywgY29kZTogc3RyaW5nKSB7XG4gICAgc3VwZXIobWVzc2FnZSk7XG5cbiAgICB0aGlzLmNvZGUgPSBjb2RlO1xuICB9XG59XG4iXX0=

package/esm2020/lib/core/exceptions-handling/errors/token-error.class.mjs

@@ -0,0 +1,7 @@
+import { AppError } from './app-error.class';
+export class TokenError extends AppError {
+    constructor() {
+        super('XPS API needs token.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4tZXJyb3IuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9leGNlcHRpb25zLWhhbmRsaW5nL2Vycm9ycy90b2tlbi1lcnJvci5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFN0MsTUFBTSxPQUFPLFVBQVcsU0FBUSxRQUFRO0lBQ3RDO1FBQ0UsS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUM7SUFDaEMsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXBwRXJyb3IgfSBmcm9tICcuL2FwcC1lcnJvci5jbGFzcyc7XG5cbmV4cG9ydCBjbGFzcyBUb2tlbkVycm9yIGV4dGVuZHMgQXBwRXJyb3Ige1xuICBwdWJsaWMgY29uc3RydWN0b3IoKSB7XG4gICAgc3VwZXIoJ1hQUyBBUEkgbmVlZHMgdG9rZW4uJyk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/core/exceptions-handling/errors/ws-error.class.mjs

@@ -0,0 +1,10 @@
+import { ErrorTags } from './elk-error-types.enum';
+import { TaggedError } from './tagged-error.class';
+export class WsError extends TaggedError {
+    constructor(message, channelName, tags) {
+        tags = tags ? [...tags, ErrorTags.WS] : [ErrorTags.WS];
+        const messageWithChannel = `${message}. ChannelName - ${channelName}`;
+        super(messageWithChannel, tags);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3MtZXJyb3IuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9leGNlcHRpb25zLWhhbmRsaW5nL2Vycm9ycy93cy1lcnJvci5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFFbkQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRW5ELE1BQU0sT0FBTyxPQUFRLFNBQVEsV0FBVztJQUN0QyxZQUFtQixPQUFlLEVBQUUsV0FBbUIsRUFBRSxJQUFrQjtRQUN6RSxJQUFJLEdBQUcsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLEdBQUcsSUFBSSxFQUFFLFNBQVMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUMsRUFBRSxDQUFDLENBQUM7UUFFdkQsTUFBTSxrQkFBa0IsR0FBRyxHQUFHLE9BQU8sbUJBQW1CLFdBQVcsRUFBRSxDQUFDO1FBRXRFLEtBQUssQ0FBQyxrQkFBa0IsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUNsQyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFcnJvclRhZ3MgfSBmcm9tICcuL2Vsay1lcnJvci10eXBlcy5lbnVtJztcblxuaW1wb3J0IHsgVGFnZ2VkRXJyb3IgfSBmcm9tICcuL3RhZ2dlZC1lcnJvci5jbGFzcyc7XG5cbmV4cG9ydCBjbGFzcyBXc0Vycm9yIGV4dGVuZHMgVGFnZ2VkRXJyb3Ige1xuICBwdWJsaWMgY29uc3RydWN0b3IobWVzc2FnZTogc3RyaW5nLCBjaGFubmVsTmFtZTogc3RyaW5nLCB0YWdzPzogRXJyb3JUYWdzW10pIHtcbiAgICB0YWdzID0gdGFncyA/IFsuLi50YWdzLCBFcnJvclRhZ3MuV1NdIDogW0Vycm9yVGFncy5XU107XG5cbiAgICBjb25zdCBtZXNzYWdlV2l0aENoYW5uZWwgPSBgJHttZXNzYWdlfS4gQ2hhbm5lbE5hbWUgLSAke2NoYW5uZWxOYW1lfWA7XG5cbiAgICBzdXBlcihtZXNzYWdlV2l0aENoYW5uZWwsIHRhZ3MpO1xuICB9XG59XG4iXX0=

package/esm2020/lib/core/payment/actions/action-factory-value.interface.mjs

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

package/esm2020/lib/core/payment/actions/action-type-command.map.mjs

@@ -0,0 +1,6 @@
+import { XpsCommand } from '../xps-comand.enum';
+export const actionTypeCommandMap = {
+    [XpsCommand.check]: 'show_fields',
+    [XpsCommand.status]: 'check_status',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aW9uLXR5cGUtY29tbWFuZC5tYXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS9wYXltZW50L2FjdGlvbnMvYWN0aW9uLXR5cGUtY29tbWFuZC5tYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBRWhELE1BQU0sQ0FBQyxNQUFNLG9CQUFvQixHQUFxQztJQUNwRSxDQUFDLFVBQVUsQ0FBQyxLQUFLLENBQUMsRUFBRSxhQUFhO0lBQ2pDLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBQyxFQUFFLGNBQWM7Q0FDcEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFhwc0NvbW1hbmQgfSBmcm9tICcuLi94cHMtY29tYW5kLmVudW0nO1xuXG5leHBvcnQgY29uc3QgYWN0aW9uVHlwZUNvbW1hbmRNYXA6IHsgW2tleSBpbiBYcHNDb21tYW5kXT86IHN0cmluZyB9ID0ge1xuICBbWHBzQ29tbWFuZC5jaGVja106ICdzaG93X2ZpZWxkcycsXG4gIFtYcHNDb21tYW5kLnN0YXR1c106ICdjaGVja19zdGF0dXMnLFxufTtcbiJdfQ==

package/esm2020/lib/core/payment/actions/action.interface.mjs

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

package/esm2020/lib/core/payment/actions/check-status/check-status.action.class.mjs

@@ -0,0 +1,16 @@
+export class CheckStatusAction {
+    constructor(submitResponse) {
+        this.type = 'check_status';
+        const status = submitResponse.parameters.status;
+        this.data = {
+            invoice: status?.invoice,
+            signature: submitResponse.parameters.form.signature?.value,
+            locale: submitResponse.parameters.form.locale?.value,
+            testPs: submitResponse.parameters.form.testPs?.value,
+            testXsolla: submitResponse.parameters.form.testXsolla?.value,
+            testProject: submitResponse.parameters.form.testProject?.value,
+            userReturnStatus: submitResponse.parameters.form.userReturnStatus?.value,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stc3RhdHVzLmFjdGlvbi5jbGFzcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3BheW1lbnQtY2xpZW50LWNvcmUvc3JjL2xpYi9jb3JlL3BheW1lbnQvYWN0aW9ucy9jaGVjay1zdGF0dXMvY2hlY2stc3RhdHVzLmFjdGlvbi5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFRQSxNQUFNLE9BQU8saUJBQWlCO0lBSTVCLFlBQW1CLGNBQThCO1FBSDFDLFNBQUksR0FBMEIsY0FBYyxDQUFDO1FBSWxELE1BQU0sTUFBTSxHQUFHLGNBQWMsQ0FBQyxVQUFVLENBQUMsTUFBbUIsQ0FBQztRQUU3RCxJQUFJLENBQUMsSUFBSSxHQUFHO1lBQ1YsT0FBTyxFQUFFLE1BQU0sRUFBRSxPQUFPO1lBQ3hCLFNBQVMsRUFBRSxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsS0FBSztZQUMxRCxNQUFNLEVBQUUsY0FBYyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUFFLEtBQUs7WUFDcEQsTUFBTSxFQUFFLGNBQWMsQ0FBQyxVQUFVLENBQUMsSUFBSSxDQUFDLE1BQU0sRUFBRSxLQUFLO1lBQ3BELFVBQVUsRUFBRSxjQUFjLENBQUMsVUFBVSxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsS0FBSztZQUM1RCxXQUFXLEVBQUUsY0FBYyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLEtBQUs7WUFDOUQsZ0JBQWdCLEVBQUUsY0FBYyxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsZ0JBQWdCLEVBQUUsS0FBSztTQUN6RSxDQUFDO0lBQ0osQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3VibWl0UmVzcG9uc2UgfSBmcm9tICcuLi8uLi9zdWJtaXQvcmVzcG9uc2Uvc3VibWl0LXJlc3BvbnNlLmNsYXNzJztcbmltcG9ydCB7IEFjdGlvbiB9IGZyb20gJy4uL2FjdGlvbi5pbnRlcmZhY2UnO1xuaW1wb3J0IHtcbiAgQ2hlY2tTdGF0dXNBY3Rpb25EYXRhLFxuICBDaGVja1N0YXR1c0FjdGlvblR5cGUsXG59IGZyb20gJy4vY2hlY2stc3RhdHVzLmFjdGlvbi50eXBlJztcbmltcG9ydCB7IFhwc1N0YXR1cyB9IGZyb20gJy4uLy4uL3hwcy1yZXNwb25zZS5pbnRlcmZhY2UnO1xuXG5leHBvcnQgY2xhc3MgQ2hlY2tTdGF0dXNBY3Rpb24gaW1wbGVtZW50cyBBY3Rpb24ge1xuICBwdWJsaWMgdHlwZTogQ2hlY2tTdGF0dXNBY3Rpb25UeXBlID0gJ2NoZWNrX3N0YXR1cyc7XG4gIHB1YmxpYyBkYXRhITogQ2hlY2tTdGF0dXNBY3Rpb25EYXRhO1xuXG4gIHB1YmxpYyBjb25zdHJ1Y3RvcihzdWJtaXRSZXNwb25zZTogU3VibWl0UmVzcG9uc2UpIHtcbiAgICBjb25zdCBzdGF0dXMgPSBzdWJtaXRSZXNwb25zZS5wYXJhbWV0ZXJzLnN0YXR1cyBhcyBYcHNTdGF0dXM7XG5cbiAgICB0aGlzLmRhdGEgPSB7XG4gICAgICBpbnZvaWNlOiBzdGF0dXM/Lmludm9pY2UsXG4gICAgICBzaWduYXR1cmU6IHN1Ym1pdFJlc3BvbnNlLnBhcmFtZXRlcnMuZm9ybS5zaWduYXR1cmU/LnZhbHVlLFxuICAgICAgbG9jYWxlOiBzdWJtaXRSZXNwb25zZS5wYXJhbWV0ZXJzLmZvcm0ubG9jYWxlPy52YWx1ZSxcbiAgICAgIHRlc3RQczogc3VibWl0UmVzcG9uc2UucGFyYW1ldGVycy5mb3JtLnRlc3RQcz8udmFsdWUsXG4gICAgICB0ZXN0WHNvbGxhOiBzdWJtaXRSZXNwb25zZS5wYXJhbWV0ZXJzLmZvcm0udGVzdFhzb2xsYT8udmFsdWUsXG4gICAgICB0ZXN0UHJvamVjdDogc3VibWl0UmVzcG9uc2UucGFyYW1ldGVycy5mb3JtLnRlc3RQcm9qZWN0Py52YWx1ZSxcbiAgICAgIHVzZXJSZXR1cm5TdGF0dXM6IHN1Ym1pdFJlc3BvbnNlLnBhcmFtZXRlcnMuZm9ybS51c2VyUmV0dXJuU3RhdHVzPy52YWx1ZSxcbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2020/lib/core/payment/actions/check-status/check-status.action.token.mjs

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { CheckStatusAction } from './check-status.action.class';
+export const checkStatusActionFactoryToken = new InjectionToken('CheckStatusAction');
+export const checkStatusActionFactoryProvider = {
+    provide: checkStatusActionFactoryToken,
+    useValue: {
+        factory: (...args) => new CheckStatusAction(...args),
+        type: 'check_status',
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2stc3RhdHVzLmFjdGlvbi50b2tlbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL3BheW1lbnQtY2xpZW50LWNvcmUvc3JjL2xpYi9jb3JlL3BheW1lbnQvYWN0aW9ucy9jaGVjay1zdGF0dXMvY2hlY2stc3RhdHVzLmFjdGlvbi50b2tlbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUU5RCxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUloRSxNQUFNLENBQUMsTUFBTSw2QkFBNkIsR0FDeEMsSUFBSSxjQUFjLENBQXFCLG1CQUFtQixDQUFDLENBQUM7QUFFOUQsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQWtCO0lBQzdELE9BQU8sRUFBRSw2QkFBNkI7SUFDdEMsUUFBUSxFQUFFO1FBQ1IsT0FBTyxFQUFFLENBQUMsR0FBRyxJQUF1QixFQUFFLEVBQUUsQ0FBQyxJQUFJLGlCQUFpQixDQUFDLEdBQUcsSUFBSSxDQUFDO1FBQ3ZFLElBQUksRUFBRSxjQUFjO0tBQ3JCO0NBQ0YsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuLCBWYWx1ZVByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBBY3Rpb25GYWN0b3J5VmFsdWUgfSBmcm9tICcuLi9hY3Rpb24tZmFjdG9yeS12YWx1ZS5pbnRlcmZhY2UnO1xuaW1wb3J0IHsgQ2hlY2tTdGF0dXNBY3Rpb24gfSBmcm9tICcuL2NoZWNrLXN0YXR1cy5hY3Rpb24uY2xhc3MnO1xuXG50eXBlIFJlcXVlc3RQYXJhbWV0ZXJzID0gQ29uc3RydWN0b3JQYXJhbWV0ZXJzPHR5cGVvZiBDaGVja1N0YXR1c0FjdGlvbj47XG5cbmV4cG9ydCBjb25zdCBjaGVja1N0YXR1c0FjdGlvbkZhY3RvcnlUb2tlbjogSW5qZWN0aW9uVG9rZW48QWN0aW9uRmFjdG9yeVZhbHVlPiA9XG4gIG5ldyBJbmplY3Rpb25Ub2tlbjxBY3Rpb25GYWN0b3J5VmFsdWU+KCdDaGVja1N0YXR1c0FjdGlvbicpO1xuXG5leHBvcnQgY29uc3QgY2hlY2tTdGF0dXNBY3Rpb25GYWN0b3J5UHJvdmlkZXI6IFZhbHVlUHJvdmlkZXIgPSB7XG4gIHByb3ZpZGU6IGNoZWNrU3RhdHVzQWN0aW9uRmFjdG9yeVRva2VuLFxuICB1c2VWYWx1ZToge1xuICAgIGZhY3Rvcnk6ICguLi5hcmdzOiBSZXF1ZXN0UGFyYW1ldGVycykgPT4gbmV3IENoZWNrU3RhdHVzQWN0aW9uKC4uLmFyZ3MpLFxuICAgIHR5cGU6ICdjaGVja19zdGF0dXMnLFxuICB9LFxufTtcbiJdfQ==

package/esm2020/lib/core/payment/actions/check-status/check-status.action.type.mjs

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

package/esm2020/lib/core/payment/actions/next-action.interface.mjs

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

package/esm2020/lib/core/payment/actions/next-action.service.mjs

@@ -0,0 +1,55 @@
+import { Inject, Injectable } from '@angular/core';
+import { nextActionsToken } from './next-actions';
+import { actionTypeCommandMap } from './action-type-command.map';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class NextActionService {
+    get flowUpdates$() {
+        return this.flowUpdatesSubject.asObservable();
+    }
+    constructor(nextActionTokens, injector) {
+        this.nextActionTokens = nextActionTokens;
+        this.injector = injector;
+        this.flowUpdatesSubject = new Subject();
+        this.nextActionsMap = new Map();
+        this.fillNextActionsMap();
+    }
+    getNextAction(submitResponse) {
+        if (!submitResponse.currentCommand) {
+            return null;
+        }
+        const nextActionFactory = this.findNextAction(submitResponse.currentCommand);
+        if (nextActionFactory) {
+            return nextActionFactory(submitResponse);
+        }
+        throw new Error('Next action is undefined.');
+    }
+    emitFlowUpdates(action) {
+        this.flowUpdatesSubject.next(action);
+    }
+    fillNextActionsMap() {
+        this.nextActionTokens.forEach((nextAction) => {
+            const item = this.injector.get(nextAction.provide);
+            this.nextActionsMap.set(item.type, item.factory);
+        });
+    }
+    findNextAction(command) {
+        const actionType = actionTypeCommandMap[command];
+        if (!actionType) {
+            return;
+        }
+        return this.nextActionsMap.get(actionType);
+    }
+}
+NextActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, deps: [{ token: nextActionsToken }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+NextActionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.7", ngImport: i0, type: NextActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [nextActionsToken]
+                }] }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/payment/actions/next-actions.mjs

@@ -0,0 +1,11 @@
+import { InjectionToken } from '@angular/core';
+import { showFieldsActionFactoryProvider } from './show-fields/show-fields.action.token';
+import { checkStatusActionFactoryProvider } from './check-status/check-status.action.token';
+import { statusUpdatedActionFactoryProvider } from './status-updated/status-updated.action.token';
+export const nextActionsToken = new InjectionToken('Action');
+export const nextActions = [
+    showFieldsActionFactoryProvider,
+    checkStatusActionFactoryProvider,
+    statusUpdatedActionFactoryProvider,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmV4dC1hY3Rpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvcGF5bWVudC1jbGllbnQtY29yZS9zcmMvbGliL2NvcmUvcGF5bWVudC9hY3Rpb25zL25leHQtYWN0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUM5RCxPQUFPLEVBQUUsK0JBQStCLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUN6RixPQUFPLEVBQUUsZ0NBQWdDLEVBQUUsTUFBTSwwQ0FBMEMsQ0FBQztBQUM1RixPQUFPLEVBQUUsa0NBQWtDLEVBQUUsTUFBTSw4Q0FBOEMsQ0FBQztBQUtsRyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLGNBQWMsQ0FBUyxRQUFRLENBQUMsQ0FBQztBQUVyRSxNQUFNLENBQUMsTUFBTSxXQUFXLEdBQXFCO0lBQzNDLCtCQUErQjtJQUMvQixnQ0FBZ0M7SUFDaEMsa0NBQWtDO0NBQ25DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgVmFsdWVQcm92aWRlciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgc2hvd0ZpZWxkc0FjdGlvbkZhY3RvcnlQcm92aWRlciB9IGZyb20gJy4vc2hvdy1maWVsZHMvc2hvdy1maWVsZHMuYWN0aW9uLnRva2VuJztcbmltcG9ydCB7IGNoZWNrU3RhdHVzQWN0aW9uRmFjdG9yeVByb3ZpZGVyIH0gZnJvbSAnLi9jaGVjay1zdGF0dXMvY2hlY2stc3RhdHVzLmFjdGlvbi50b2tlbic7XG5pbXBvcnQgeyBzdGF0dXNVcGRhdGVkQWN0aW9uRmFjdG9yeVByb3ZpZGVyIH0gZnJvbSAnLi9zdGF0dXMtdXBkYXRlZC9zdGF0dXMtdXBkYXRlZC5hY3Rpb24udG9rZW4nO1xuaW1wb3J0IHsgQWN0aW9uIH0gZnJvbSAnLi9hY3Rpb24uaW50ZXJmYWNlJztcblxuZXhwb3J0IHR5cGUgTmV4dEFjdGlvblRva2VucyA9IFZhbHVlUHJvdmlkZXJbXTtcblxuZXhwb3J0IGNvbnN0IG5leHRBY3Rpb25zVG9rZW4gPSBuZXcgSW5qZWN0aW9uVG9rZW48QWN0aW9uPignQWN0aW9uJyk7XG5cbmV4cG9ydCBjb25zdCBuZXh0QWN0aW9uczogTmV4dEFjdGlvblRva2VucyA9IFtcbiAgc2hvd0ZpZWxkc0FjdGlvbkZhY3RvcnlQcm92aWRlcixcbiAgY2hlY2tTdGF0dXNBY3Rpb25GYWN0b3J5UHJvdmlkZXIsXG4gIHN0YXR1c1VwZGF0ZWRBY3Rpb25GYWN0b3J5UHJvdmlkZXIsXG5dO1xuIl19