@xsolla/payment-client-core 0.2.21 → 0.2.23

package/esm2022/lib/core/session/session.service.mjs

@@ -0,0 +1,57 @@
+import { Inject, Injectable } from '@angular/core';
+import { isNull } from '../type-guards/is-null.function';
+import { isUndefined } from '../type-guards/is-undefined.function';
+import { windowToken } from '../window.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../settings/settings.service";
+export class SessionService {
+    constructor(window, settingsService) {
+        this.window = window;
+        this.settingsService = settingsService;
+        this.cache = {};
+    }
+    /**
+     * @param {string} key must be uniq entire all app
+     * @param {unknown} value can be anything
+     */
+    set(key, value) {
+        this.cache[key] = value;
+        try {
+            this.window.sessionStorage.setItem(this.getStorageKey(key), JSON.stringify(value));
+        }
+        catch (error) {
+            console.warn('Session storage not available.');
+        }
+    }
+    get(key) {
+        const cacheValue = this.cache[key];
+        if (!isUndefined(cacheValue)) {
+            return cacheValue;
+        }
+        try {
+            const storageValue = this.window.sessionStorage.getItem(this.getStorageKey(key));
+            if (isNull(storageValue)) {
+                return null;
+            }
+            return JSON.parse(storageValue);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    getStorageKey(key) {
+        return `${key}${this.settingsService.token}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SessionService, deps: [{ token: windowToken }, { token: i1.SettingsService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SessionService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }, { type: i1.SettingsService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/settings/settings.service.mjs

@@ -0,0 +1,92 @@
+import { firstValueFrom } from 'rxjs';
+import { Injectable } from '@angular/core';
+import { HttpParams } from '@angular/common/http';
+import { EmptyUtilsResponseError } from './empty-utils-response.error';
+import * as i0 from "@angular/core";
+import * as i1 from "../http/secure-api/secure-api.service";
+export class SettingsService {
+    get project() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.project;
+    }
+    get purchase() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.purchase;
+    }
+    get settings() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        if (this.response?.purchase_external_id) {
+            return {
+                ...this.response.settings,
+                purchase_external_id: this.response.purchase_external_id,
+            };
+        }
+        return this.response?.settings;
+    }
+    get user() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response.user;
+    }
+    get utilsResponse() {
+        if (!this.response) {
+            throw new EmptyUtilsResponseError();
+        }
+        return this.response;
+    }
+    get unsafeUtilsResponse() {
+        return this.response ?? null;
+    }
+    get isEmpty() {
+        return !this.response;
+    }
+    get token() {
+        return this._token;
+    }
+    get hasResponse() {
+        return !!this.response;
+    }
+    constructor(secureApi) {
+        this.secureApi = secureApi;
+        this.isInitialized = false;
+        this._token = '';
+        this.sandboxMode = false;
+    }
+    async init(configuration) {
+        if (!configuration.token) {
+            return Promise.reject('token is missing');
+        }
+        this._token = configuration.token;
+        this.sandboxMode = !!configuration.sandbox;
+        this._refer = configuration.refer;
+        await this.sendRequest(this.token);
+        this.isInitialized = true;
+    }
+    isSandboxMode() {
+        return this.sandboxMode;
+    }
+    get refer() {
+        return this._refer;
+    }
+    async sendRequest(token) {
+        const params = new HttpParams().set('access_token', token);
+        this.secureApi.setSandboxMode(this.isSandboxMode());
+        this.response = await firstValueFrom(this.secureApi.get('utils', { params }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SettingsService, deps: [{ token: i1.SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SettingsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SecureApiClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/url/url.service.mjs

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class UrlService {
+    addSearchParams(url, params = {}) {
+        if (!url) {
+            return '';
+        }
+        const urlObject = new URL(url);
+        for (const [key, value] of Object.entries(params)) {
+            urlObject.searchParams.set(key, value);
+        }
+        return urlObject.toString();
+    }
+    getSearchParams(url) {
+        if (!url) {
+            return {};
+        }
+        const urlObject = new URL(url);
+        const searchParams = {};
+        for (const [key, value] of urlObject.searchParams) {
+            searchParams[key] = value;
+        }
+        return searchParams;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UrlService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UrlService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UrlService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/core/user-agent/user-agent.service.mjs

@@ -0,0 +1,211 @@
+import { Inject, Injectable } from '@angular/core';
+import { browsers, unknownValue } from './browsers';
+import { Device } from './device.enum';
+import { windowToken } from '../window.token';
+import { osList } from './os';
+import * as i0 from "@angular/core";
+export class UserAgentService {
+    constructor(window) {
+        this.window = window;
+        this._browserName = null;
+        this._browserVersion = null;
+        this._browserApp = null;
+        this._platform = null;
+        this._os = null;
+        this.getUserPlatform();
+        this.getBrowserInformation();
+        this.getOsInformation();
+    }
+    get browserVersion() {
+        return this._browserVersion;
+    }
+    get browserApp() {
+        return this._browserApp;
+    }
+    get platform() {
+        if (this._platform === unknownValue) {
+            return this.osType;
+        }
+        return this._platform;
+    }
+    get userAgent() {
+        return this.window.navigator.userAgent;
+    }
+    get browserDescription() {
+        if (this.browserName === unknownValue || this.browserName === null) {
+            return this.userAgent;
+        }
+        return this.browserName;
+    }
+    get isSafari() {
+        return this._browserName === 'Apple Safari';
+    }
+    get safariVersion() {
+        if (!this.isSafari) {
+            return null;
+        }
+        const versionRegExp = new RegExp('(Version)\\/(.+)\\s');
+        const version = versionRegExp.exec(this.userAgent);
+        if (!version) {
+            return null;
+        }
+        return Number(version[2].split('.')[0]);
+    }
+    get iOsVersion() {
+        if (this.osType !== 'ios') {
+            return null;
+        }
+        const version = /OS (\d+)_(\d+)_?(\d+)?/.exec(this.window.navigator.appVersion);
+        return version ? `${version[1]}.${version[2]}.${version[3] ?? 0}` : null;
+    }
+    get browserInfo() {
+        const browserInfo = {
+            name: this.browserDescription,
+            [this.browserApp?.toLowerCase() ?? unknownValue]: true,
+            version: this.browserVersion,
+            [this.browserEngine.toLowerCase()]: true,
+            ui_version: this.isMobileDevice ? Device.mobile : Device.desktop,
+            os: this.os,
+        };
+        if (this.isMobileDevice) {
+            browserInfo.mobile = true;
+        }
+        if (this.osType) {
+            // @ts-expect-error index is string
+            browserInfo[this.osType.toLowerCase()] = true;
+        }
+        if (this.window.navigator.platform?.includes('iPhone')) {
+            browserInfo.iphone = true;
+        }
+        if (this.window.navigator.platform?.includes('iPod')) {
+            browserInfo.ipod = true;
+        }
+        if (this.window.navigator.platform?.includes('iPad')) {
+            browserInfo.ipad = true;
+            browserInfo.tablet = true;
+        }
+        if (this.isAndroid) {
+            browserInfo.android = true;
+        }
+        return browserInfo;
+    }
+    get isMobileDevice() {
+        const deviceAgents = [
+            'Android',
+            'webOS',
+            'iPhone',
+            'iPad',
+            'iPod',
+            'BlackBerry',
+            'IEMobile',
+            'Opera Mini',
+            'Mobile',
+            'Tablet',
+            'Kindle',
+            'Playbook',
+            'Silk',
+            'Puffin',
+            'CriOS',
+        ];
+        return new RegExp(deviceAgents.join('|'), 'i').test(this.userAgent);
+    }
+    get isIosAndNotIpad() {
+        return ['iPhone', 'iPod'].includes(this.window.navigator.platform);
+    }
+    getUserPlatform() {
+        const experimentalPlatformApi = this.window.navigator?.userAgentData;
+        const platform = experimentalPlatformApi?.platform ??
+            this.window?.navigator?.platform ??
+            unknownValue;
+        this._platform = platform.toLowerCase();
+    }
+    getBrowserInformation() {
+        for (const browser of browsers) {
+            const browserRegExp = new RegExp(browser.regexpBrowserNameWithVersion);
+            const browserNameWithVersion = browserRegExp.exec(this.userAgent);
+            if (browserNameWithVersion !== null) {
+                this._browserName = browser.sentName;
+                this._browserApp = browser.shortName;
+                this._browserVersion = browserNameWithVersion[2];
+                break;
+            }
+            this._browserName = unknownValue;
+            this._browserApp = unknownValue;
+            this._browserVersion = unknownValue;
+        }
+    }
+    getOsInformation() {
+        for (const os of osList) {
+            const osRegExp = new RegExp(os.regExp);
+            const osName = osRegExp.exec(this.userAgent);
+            if (osName !== null) {
+                this._os = os.name;
+                break;
+            }
+            this._os = unknownValue;
+        }
+    }
+    get browserName() {
+        return this._browserName;
+    }
+    get isAndroid() {
+        return /Android\s+([\d.]+)/.test(this.userAgent);
+    }
+    get isXbox() {
+        return /xbox/i.test(this.userAgent);
+    }
+    get isLinux() {
+        return /linux/i.test(this.userAgent);
+    }
+    get isWindows() {
+        return /windows/i.test(this.userAgent);
+    }
+    get browserEngine() {
+        const engines = new Map([
+            ['Firefox', 'Gecko'],
+            ['Safari', 'Webkit'],
+            ['MSEdge-legacy', 'EdgeHTML'],
+            ['Chrome', 'Blink'],
+            ['Opera', 'Blink'],
+            ['MSEdge', 'Blink'],
+            ['SamsungBrowser', 'Blink'],
+        ]);
+        return engines.get(this.browserApp) ?? unknownValue;
+    }
+    get os() {
+        return this._os;
+    }
+    get osType() {
+        if (['iPhone', 'iPod', 'iPad'].includes(this.window.navigator.platform)) {
+            return 'ios';
+        }
+        if (this.window.navigator.platform?.includes('MacIntel')) {
+            return 'mac';
+        }
+        if (this.isXbox) {
+            return 'xbox';
+        }
+        if (this.isWindows) {
+            return 'windows';
+        }
+        if (this.isAndroid) {
+            return 'android';
+        }
+        if (this.isLinux) {
+            return 'linux';
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserAgentService, deps: [{ token: windowToken }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserAgentService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserAgentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [windowToken]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-agent.service.js","sourceRoot":"","sources":["../../../../../../packages/payment-client-core/src/lib/core/user-agent/user-agent.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { browsers, BrowserName, BrowserApp, unknownValue } from './browsers';\nimport { Device } from './device.enum';\nimport { windowToken } from '../window.token';\nimport { ExtendedWindow } from '../extended-window.interface';\nimport { BrowserInfo } from './browserInfo.interface';\nimport { osList } from './os';\nimport { UserAgentData } from './user-agent-data.interface';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class UserAgentService {\n  private _browserName: BrowserName = null;\n  private _browserVersion: string | null = null;\n  private _browserApp: BrowserApp = null;\n  private _platform: string | null = null;\n  private _os: string | null = null;\n\n  public constructor(\n    @Inject(windowToken)\n    private readonly window: ExtendedWindow\n  ) {\n    this.getUserPlatform();\n    this.getBrowserInformation();\n    this.getOsInformation();\n  }\n\n  public get browserVersion(): string | null {\n    return this._browserVersion;\n  }\n\n  public get browserApp(): BrowserApp {\n    return this._browserApp;\n  }\n\n  public get platform(): string | null {\n    if (this._platform === unknownValue) {\n      return this.osType;\n    }\n\n    return this._platform;\n  }\n\n  public get userAgent(): string {\n    return this.window.navigator.userAgent;\n  }\n\n  public get browserDescription():\n    | typeof browsers[number]['sentName']\n    | string {\n    if (this.browserName === unknownValue || this.browserName === null) {\n      return this.userAgent;\n    }\n\n    return this.browserName;\n  }\n\n  public get isSafari(): boolean {\n    return this._browserName === 'Apple Safari';\n  }\n\n  public get safariVersion(): null | number {\n    if (!this.isSafari) {\n      return null;\n    }\n\n    const versionRegExp = new RegExp('(Version)\\\\/(.+)\\\\s');\n    const version = versionRegExp.exec(this.userAgent);\n    if (!version) {\n      return null;\n    }\n\n    return Number(version[2].split('.')[0]);\n  }\n\n  public get iOsVersion(): string | null {\n    if (this.osType !== 'ios') {\n      return null;\n    }\n\n    const version = /OS (\\d+)_(\\d+)_?(\\d+)?/.exec(\n      this.window.navigator.appVersion\n    );\n\n    return version ? `${version[1]}.${version[2]}.${version[3] ?? 0}` : null;\n  }\n\n  public get browserInfo(): BrowserInfo {\n    const browserInfo: BrowserInfo = {\n      name: this.browserDescription,\n      [this.browserApp?.toLowerCase() ?? unknownValue]: true,\n      version: this.browserVersion,\n      [this.browserEngine.toLowerCase()]: true,\n      ui_version: this.isMobileDevice ? Device.mobile : Device.desktop,\n      os: this.os,\n    };\n\n    if (this.isMobileDevice) {\n      browserInfo.mobile = true;\n    }\n\n    if (this.osType) {\n      // @ts-expect-error index is string\n      browserInfo[this.osType.toLowerCase()] = true;\n    }\n\n    if (this.window.navigator.platform?.includes('iPhone')) {\n      browserInfo.iphone = true;\n    }\n\n    if (this.window.navigator.platform?.includes('iPod')) {\n      browserInfo.ipod = true;\n    }\n\n    if (this.window.navigator.platform?.includes('iPad')) {\n      browserInfo.ipad = true;\n      browserInfo.tablet = true;\n    }\n\n    if (this.isAndroid) {\n      browserInfo.android = true;\n    }\n\n    return browserInfo;\n  }\n\n  public get isMobileDevice(): boolean {\n    const deviceAgents = [\n      'Android',\n      'webOS',\n      'iPhone',\n      'iPad',\n      'iPod',\n      'BlackBerry',\n      'IEMobile',\n      'Opera Mini',\n      'Mobile',\n      'Tablet',\n      'Kindle',\n      'Playbook',\n      'Silk',\n      'Puffin',\n      'CriOS',\n    ];\n    return new RegExp(deviceAgents.join('|'), 'i').test(this.userAgent);\n  }\n\n  public get isIosAndNotIpad(): boolean {\n    return ['iPhone', 'iPod'].includes(this.window.navigator.platform);\n  }\n\n  private getUserPlatform(): void {\n    const experimentalPlatformApi = (\n      this.window.navigator as unknown as {\n        userAgentData: UserAgentData | undefined;\n      }\n    )?.userAgentData;\n\n    const platform =\n      experimentalPlatformApi?.platform ??\n      this.window?.navigator?.platform ??\n      unknownValue;\n\n    this._platform = platform.toLowerCase();\n  }\n\n  private getBrowserInformation(): void {\n    for (const browser of browsers) {\n      const browserRegExp = new RegExp(browser.regexpBrowserNameWithVersion);\n      const browserNameWithVersion = browserRegExp.exec(this.userAgent);\n\n      if (browserNameWithVersion !== null) {\n        this._browserName = browser.sentName;\n        this._browserApp = browser.shortName;\n        this._browserVersion = browserNameWithVersion[2];\n        break;\n      }\n\n      this._browserName = unknownValue;\n      this._browserApp = unknownValue;\n      this._browserVersion = unknownValue;\n    }\n  }\n\n  private getOsInformation(): void {\n    for (const os of osList) {\n      const osRegExp = new RegExp(os.regExp);\n      const osName = osRegExp.exec(this.userAgent);\n\n      if (osName !== null) {\n        this._os = os.name;\n        break;\n      }\n\n      this._os = unknownValue;\n    }\n  }\n\n  private get browserName(): BrowserName {\n    return this._browserName;\n  }\n\n  private get isAndroid(): boolean {\n    return /Android\\s+([\\d.]+)/.test(this.userAgent);\n  }\n\n  private get isXbox(): boolean {\n    return /xbox/i.test(this.userAgent);\n  }\n\n  private get isLinux(): boolean {\n    return /linux/i.test(this.userAgent);\n  }\n\n  private get isWindows(): boolean {\n    return /windows/i.test(this.userAgent);\n  }\n\n  private get browserEngine(): string {\n    const engines = new Map<BrowserApp, string>([\n      ['Firefox', 'Gecko'],\n      ['Safari', 'Webkit'],\n      ['MSEdge-legacy', 'EdgeHTML'],\n      ['Chrome', 'Blink'],\n      ['Opera', 'Blink'],\n      ['MSEdge', 'Blink'],\n      ['SamsungBrowser', 'Blink'],\n    ]);\n\n    return engines.get(this.browserApp) ?? unknownValue;\n  }\n\n  private get os(): string | null {\n    return this._os;\n  }\n\n  private get osType(): string | null {\n    if (['iPhone', 'iPod', 'iPad'].includes(this.window.navigator.platform)) {\n      return 'ios';\n    }\n\n    if (this.window.navigator.platform?.includes('MacIntel')) {\n      return 'mac';\n    }\n\n    if (this.isXbox) {\n      return 'xbox';\n    }\n    if (this.isWindows) {\n      return 'windows';\n    }\n\n    if (this.isAndroid) {\n      return 'android';\n    }\n\n    if (this.isLinux) {\n      return 'linux';\n    }\n\n    return null;\n  }\n}\n"]}

package/esm2022/lib/core/user-balance/user-balance.service.mjs

@@ -0,0 +1,53 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { lastValueFrom, map } from 'rxjs';
+import { ResponseError } from '../exceptions-handling/errors/response-error.class';
+import { userBalanceResponseFactoryToken, } from './user-balance-response.token';
+import * as i0 from "@angular/core";
+import * as i1 from "../settings/settings.service";
+import * as i2 from "../http/secure-api/secure-api.service";
+export class UserBalanceService {
+    constructor(responseFactory, settingsService, secureApi) {
+        this.responseFactory = responseFactory;
+        this.settingsService = settingsService;
+        this.secureApi = secureApi;
+        this.apiRoute = 'balance/sufficiency';
+        this.cache = new Map();
+    }
+    async getUserBalance() {
+        return this.request();
+    }
+    getUserBalanceValue() {
+        return this.settingsService.user.user_balance;
+    }
+    async request() {
+        const requestParams = {
+            access_token: this.settingsService.token,
+        };
+        const cacheKey = JSON.stringify(requestParams);
+        if (!this.cache.has(cacheKey)) {
+            this.cache.set(cacheKey, lastValueFrom(this.secureApi
+                .post(this.apiRoute, new URLSearchParams({ ...requestParams }), {
+                headers: new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded; charset=utf-8'),
+                responseType: 'json',
+            })
+                .pipe(map((response) => this.responseFactory(response)))).catch((error) => {
+                throw new ResponseError(error.message);
+            }));
+        }
+        // @ts-expect-error the map already has the cache with key
+        return this.cache.get(cacheKey);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBalanceService, deps: [{ token: userBalanceResponseFactoryToken }, { token: i1.SettingsService }, { token: i2.SecureApiClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBalanceService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: UserBalanceService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [userBalanceResponseFactoryToken]
+                }] }, { type: i1.SettingsService }, { type: i2.SecureApiClient }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci1iYWxhbmNlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9wYXltZW50LWNsaWVudC1jb3JlL3NyYy9saWIvY29yZS91c2VyLWJhbGFuY2UvdXNlci1iYWxhbmNlLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSxhQUFhLEVBQUUsR0FBRyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxvREFBb0QsQ0FBQztBQUduRixPQUFPLEVBRUwsK0JBQStCLEdBQ2hDLE1BQU0sK0JBQStCLENBQUM7Ozs7QUFTdkMsTUFBTSxPQUFPLGtCQUFrQjtJQUs3QixZQUVtQixlQUEyQyxFQUMzQyxlQUFnQyxFQUNoQyxTQUEwQjtRQUYxQixvQkFBZSxHQUFmLGVBQWUsQ0FBNEI7UUFDM0Msb0JBQWUsR0FBZixlQUFlLENBQWlCO1FBQ2hDLGNBQVMsR0FBVCxTQUFTLENBQWlCO1FBUjVCLGFBQVEsR0FBRyxxQkFBcUIsQ0FBQztRQUVqQyxVQUFLLEdBQUcsSUFBSSxHQUFHLEVBQXdDLENBQUM7SUFPdEUsQ0FBQztJQUVHLEtBQUssQ0FBQyxjQUFjO1FBQ3pCLE9BQU8sSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQ3hCLENBQUM7SUFFTSxtQkFBbUI7UUFDeEIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUM7SUFDaEQsQ0FBQztJQUVPLEtBQUssQ0FBQyxPQUFPO1FBQ25CLE1BQU0sYUFBYSxHQUE2QjtZQUM5QyxZQUFZLEVBQUUsSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLO1NBQ3pDLENBQUM7UUFDRixNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBRS9DLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsRUFBRSxDQUFDO1lBQzlCLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUNaLFFBQVEsRUFDUixhQUFhLENBQ1gsSUFBSSxDQUFDLFNBQVM7aUJBQ1gsSUFBSSxDQUNILElBQUksQ0FBQyxRQUFRLEVBQ2IsSUFBSSxlQUFlLENBQUMsRUFBRSxHQUFHLGFBQWEsRUFBRSxDQUFDLEVBQ3pDO2dCQUNFLE9BQU8sRUFBRSxJQUFJLFdBQVcsRUFBRSxDQUFDLEdBQUcsQ0FDNUIsY0FBYyxFQUNkLGtEQUFrRCxDQUNuRDtnQkFDRCxZQUFZLEVBQUUsTUFBTTthQUNyQixDQUNGO2lCQUNBLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUMzRCxDQUFDLEtBQUssQ0FBQyxDQUFDLEtBQVksRUFBRSxFQUFFO2dCQUN2QixNQUFNLElBQUksYUFBYSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztZQUN6QyxDQUFDLENBQUMsQ0FDSCxDQUFDO1FBQ0osQ0FBQztRQUVELDBEQUEwRDtRQUMxRCxPQUFPLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7OEdBbkRVLGtCQUFrQixrQkFNbkIsK0JBQStCO2tIQU45QixrQkFBa0IsY0FGakIsTUFBTTs7MkZBRVAsa0JBQWtCO2tCQUg5QixVQUFVO21CQUFDO29CQUNWLFVBQVUsRUFBRSxNQUFNO2lCQUNuQjs7MEJBT0ksTUFBTTsyQkFBQywrQkFBK0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwSGVhZGVycyB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbi9odHRwJztcbmltcG9ydCB7IEluamVjdCwgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgbGFzdFZhbHVlRnJvbSwgbWFwIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBSZXNwb25zZUVycm9yIH0gZnJvbSAnLi4vZXhjZXB0aW9ucy1oYW5kbGluZy9lcnJvcnMvcmVzcG9uc2UtZXJyb3IuY2xhc3MnO1xuaW1wb3J0IHsgU2VjdXJlQXBpQ2xpZW50IH0gZnJvbSAnLi4vaHR0cC9zZWN1cmUtYXBpL3NlY3VyZS1hcGkuc2VydmljZSc7XG5pbXBvcnQgeyBTZXR0aW5nc1NlcnZpY2UgfSBmcm9tICcuLi9zZXR0aW5ncy9zZXR0aW5ncy5zZXJ2aWNlJztcbmltcG9ydCB7XG4gIFVzZXJCYWxhbmNlUmVzcG9uc2VGYWN0b3J5LFxuICB1c2VyQmFsYW5jZVJlc3BvbnNlRmFjdG9yeVRva2VuLFxufSBmcm9tICcuL3VzZXItYmFsYW5jZS1yZXNwb25zZS50b2tlbic7XG5pbXBvcnQgeyBVc2VyQmFsYW5jZVJlc3BvbnNlIH0gZnJvbSAnLi91c2VyLWJhbGFuY2UtcmVzcG9uc2UuY2xhc3MnO1xuaW1wb3J0IHsgVXNlckJhbGFuY2VSZXF1ZXN0UGFyYW1zIH0gZnJvbSAnLi91c2VyLWJhbGFuY2UtcmVxdWVzdC1wYXJhbXMuaW50ZXJmYWNlJztcbmltcG9ydCB7IFVzZXJCYWxhbmNlQXBpIH0gZnJvbSAnLi91c2VyLWJhbGFuY2UtYXBpLmludGVyZmFjZSc7XG5pbXBvcnQgeyBCYWxhbmNlIH0gZnJvbSAnLi4vc2V0dGluZ3MvYmFsYW5jZS5pbnRlcmZhY2UnO1xuXG5ASW5qZWN0YWJsZSh7XG4gIHByb3ZpZGVkSW46ICdyb290Jyxcbn0pXG5leHBvcnQgY2xhc3MgVXNlckJhbGFuY2VTZXJ2aWNlIHtcbiAgcHJpdmF0ZSByZWFkb25seSBhcGlSb3V0ZSA9ICdiYWxhbmNlL3N1ZmZpY2llbmN5JztcblxuICBwcml2YXRlIHJlYWRvbmx5IGNhY2hlID0gbmV3IE1hcDxzdHJpbmcsIFByb21pc2U8VXNlckJhbGFuY2VSZXNwb25zZT4+KCk7XG5cbiAgcHVibGljIGNvbnN0cnVjdG9yKFxuICAgIEBJbmplY3QodXNlckJhbGFuY2VSZXNwb25zZUZhY3RvcnlUb2tlbilcbiAgICBwcml2YXRlIHJlYWRvbmx5IHJlc3BvbnNlRmFjdG9yeTogVXNlckJhbGFuY2VSZXNwb25zZUZhY3RvcnksXG4gICAgcHJpdmF0ZSByZWFkb25seSBzZXR0aW5nc1NlcnZpY2U6IFNldHRpbmdzU2VydmljZSxcbiAgICBwcml2YXRlIHJlYWRvbmx5IHNlY3VyZUFwaTogU2VjdXJlQXBpQ2xpZW50XG4gICkge31cblxuICBwdWJsaWMgYXN5bmMgZ2V0VXNlckJhbGFuY2UoKTogUHJvbWlzZTxVc2VyQmFsYW5jZVJlc3BvbnNlPiB7XG4gICAgcmV0dXJuIHRoaXMucmVxdWVzdCgpO1xuICB9XG5cbiAgcHVibGljIGdldFVzZXJCYWxhbmNlVmFsdWUoKTogQmFsYW5jZSB8IG51bGwge1xuICAgIHJldHVybiB0aGlzLnNldHRpbmdzU2VydmljZS51c2VyLnVzZXJfYmFsYW5jZTtcbiAgfVxuXG4gIHByaXZhdGUgYXN5bmMgcmVxdWVzdCgpOiBQcm9taXNlPFVzZXJCYWxhbmNlUmVzcG9uc2U+IHtcbiAgICBjb25zdCByZXF1ZXN0UGFyYW1zOiBVc2VyQmFsYW5jZVJlcXVlc3RQYXJhbXMgPSB7XG4gICAgICBhY2Nlc3NfdG9rZW46IHRoaXMuc2V0dGluZ3NTZXJ2aWNlLnRva2VuLFxuICAgIH07XG4gICAgY29uc3QgY2FjaGVLZXkgPSBKU09OLnN0cmluZ2lmeShyZXF1ZXN0UGFyYW1zKTtcblxuICAgIGlmICghdGhpcy5jYWNoZS5oYXMoY2FjaGVLZXkpKSB7XG4gICAgICB0aGlzLmNhY2hlLnNldChcbiAgICAgICAgY2FjaGVLZXksXG4gICAgICAgIGxhc3RWYWx1ZUZyb20oXG4gICAgICAgICAgdGhpcy5zZWN1cmVBcGlcbiAgICAgICAgICAgIC5wb3N0PFVzZXJCYWxhbmNlQXBpPihcbiAgICAgICAgICAgICAgdGhpcy5hcGlSb3V0ZSxcbiAgICAgICAgICAgICAgbmV3IFVSTFNlYXJjaFBhcmFtcyh7IC4uLnJlcXVlc3RQYXJhbXMgfSksXG4gICAgICAgICAgICAgIHtcbiAgICAgICAgICAgICAgICBoZWFkZXJzOiBuZXcgSHR0cEhlYWRlcnMoKS5zZXQoXG4gICAgICAgICAgICAgICAgICAnQ29udGVudC1UeXBlJyxcbiAgICAgICAgICAgICAgICAgICdhcHBsaWNhdGlvbi94LXd3dy1mb3JtLXVybGVuY29kZWQ7IGNoYXJzZXQ9dXRmLTgnXG4gICAgICAgICAgICAgICAgKSxcbiAgICAgICAgICAgICAgICByZXNwb25zZVR5cGU6ICdqc29uJyxcbiAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgKVxuICAgICAgICAgICAgLnBpcGUobWFwKChyZXNwb25zZSkgPT4gdGhpcy5yZXNwb25zZUZhY3RvcnkocmVzcG9uc2UpKSlcbiAgICAgICAgKS5jYXRjaCgoZXJyb3I6IEVycm9yKSA9PiB7XG4gICAgICAgICAgdGhyb3cgbmV3IFJlc3BvbnNlRXJyb3IoZXJyb3IubWVzc2FnZSk7XG4gICAgICAgIH0pXG4gICAgICApO1xuICAgIH1cblxuICAgIC8vIEB0cy1leHBlY3QtZXJyb3IgdGhlIG1hcCBhbHJlYWR5IGhhcyB0aGUgY2FjaGUgd2l0aCBrZXlcbiAgICByZXR1cm4gdGhpcy5jYWNoZS5nZXQoY2FjaGVLZXkpO1xuICB9XG59XG4iXX0=