@secrethub/ngx-stripe
Version:
The core package for ngx-stripe, for using stripe.js in your application
388 lines (379 loc) • 38 kB
JavaScript
import { InjectionToken, NgModule, Inject, Injectable, defineInjectable, inject } from '@angular/core';
import { Observable, BehaviorSubject } from 'rxjs';
import { __awaiter } from 'tslib';
import { filter, first } from 'rxjs/operators';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* The public key that should be used for connecting to Stripe
* @type {?}
*/
const STRIPE_PUBLIC_KEY = new InjectionToken('Stripe public key');
/**
* Extra configuration options that can be used to further configure Stripe
* @type {?}
*/
const STRIPE_OPTIONS = new InjectionToken('Optional configuration options');
/**
* The version of stripe that should be used
* @type {?}
*/
const STRIPE_VERSION = new InjectionToken('Stripe version to use');
/**
* The location of the stripe javascript file
* @type {?}
*/
const STRIPE_SCRIPT_LOCATION = 'https://js.stripe.com/';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/** @enum {string} */
const SupportedVersions = {
V3: 'v3',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class NgxStripeModule {
/**
* Creates a new instance of the NgxStripeModule
* @param {?} key - The public key that should be used to communicate with Stripe
* @param {?=} options - Any options to configure StripeJS
* @param {?=} version
* @return {?}
*/
static forRoot(key, options, version = SupportedVersions.V3) {
return {
ngModule: NgxStripeModule,
providers: [
{ provide: STRIPE_PUBLIC_KEY, useValue: key },
{ provide: STRIPE_OPTIONS, useValue: options },
{ provide: STRIPE_VERSION, useValue: version },
],
};
}
}
NgxStripeModule.decorators = [
{ type: NgModule, args: [{
imports: [],
},] }
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class StripeLoader {
/**
* @param {?} version
* @param {?} options
* @param {?} key
*/
constructor(version, options, key) {
this.version = version;
this.options = options;
this.key = key;
}
/**
* Fetches the stripe instance from the DOM
*
* @param {?} key
* @param {?} options
* @return {?} The Stripe instance or null if it is not yet registered
*/
static getStripeInstance(key, options) {
/** @type {?} */
const stripeInstance = window[StripeLoader.STRIPE_WINDOW_KEY];
if (stripeInstance) {
return stripeInstance(key, options);
}
return null;
}
/**
* Checks whether or not StripeJS has been loaded
* @return {?}
*/
static isStripeLoaded() {
return !!window[StripeLoader.STRIPE_WINDOW_KEY];
}
/**
* Injects the script tag into the body of the page in order to lazy
* load the Stripe script
*
* @return {?} Observable to indicate when the script has finished loading
*/
loadScript() {
return new Observable((observer) => {
if (!StripeLoader.isStripeLoaded()) {
/** @type {?} */
const script = StripeLoader.constructScript(this.getStripeScriptUrl());
script.onload = (() => {
observer.next(StripeLoader.getStripeInstance(this.key, this.options));
observer.complete();
});
script.onerror = () => {
observer.error('Failed to load the Stripe script!');
observer.complete();
};
document.body.appendChild(script);
}
else {
observer.next(StripeLoader.getStripeInstance(this.key, this.options));
observer.complete();
}
});
}
/**
* Constructs the url that should be used for loading the Stripe script
* @return {?} URL to stripe script location
*/
getStripeScriptUrl() {
return STRIPE_SCRIPT_LOCATION + this.version + '/';
}
/**
* Constructs a script element that loads javascript from the given url
* @param {?} url - The URL from which the javascript should be loaded
*
* @return {?} A script element that can be attached to the DOM
*/
static constructScript(url) {
/** @type {?} */
const script = document.createElement('script');
script.type = 'text/javascript';
script.async = true;
script.defer = true;
script.src = url;
return script;
}
}
/**
* The key under which the stripe script is placed in the
* window object
*
* @default 'Stripe'
*/
StripeLoader.STRIPE_WINDOW_KEY = 'Stripe';
StripeLoader.decorators = [
{ type: Injectable, args: [{
providedIn: 'root',
},] }
];
StripeLoader.ctorParameters = () => [
{ type: SupportedVersions, decorators: [{ type: Inject, args: [STRIPE_VERSION,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [STRIPE_OPTIONS,] }] },
{ type: String, decorators: [{ type: Inject, args: [STRIPE_PUBLIC_KEY,] }] }
];
/** @nocollapse */ StripeLoader.ngInjectableDef = defineInjectable({ factory: function StripeLoader_Factory() { return new StripeLoader(inject(STRIPE_VERSION), inject(STRIPE_OPTIONS), inject(STRIPE_PUBLIC_KEY)); }, token: StripeLoader, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
class StripeService {
/**
* Lazy load the StripeJS javascript file on first usage of the service
* @param {?} loader - The loader that should be used for loading StripeJS
*/
constructor(loader) {
this.loader = loader;
/**
* A BehaviorSubject containing the StripeJS object
*
* Since the script is loaded Async we need an options for all our functions
* to wait for stripe to have been loaded
*/
this.stripe$ = new BehaviorSubject(null);
loader.loadScript()
.subscribe((stripe) => this.stripe$.next(stripe), () => {
throw new Error('Stripe could not be loaded!');
});
}
/**
* Creates a new stripe instance with the given key
* @param {?} key - The public key that should be used to communicate with Stripe
* @param {?=} options - Any options to configure StripeJS
* @return {?}
*/
changeKey(key, options) {
this.stripe$.next(StripeLoader.getStripeInstance(key, options));
}
/**
* Configures the `Elements` object from StripeJS with the given options
* @see https://stripe.com/docs/stripe-js/elements/quickstart#create-form
* @param {?=} options
* @param {?=} isIETFLocaleTag
* @return {?} Observable that resolves in an StripeJS ElementsCreator
*/
getElementFactory(options, isIETFLocaleTag = false) {
return __awaiter(this, void 0, void 0, function* () {
if (isIETFLocaleTag && options && options.locale) {
options.locale = options.locale.split('-')[0]; // Only use the first part of the locale 'en' for example
}
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.elements(options);
});
}
/**
* Create a payment request
* NOTE: This is NOT supported for Firefox
* @see https://stripe.com/docs/payment-request-api
*
* @param {?} options - Payment information that should be used by Stripe
*
* @return {?} the created request
*/
makePaymentRequest(options) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.paymentRequest(options);
});
}
/**
* Creates a token from the given element
*
* @param {?} element - The element from which the data needs to be extracted
* @param {?=} data
* @return {?} A promise that resolves in a token or a rejection if the creation of the token failed
*/
createTokenFromElement(element, data) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.createToken(element, data).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.token;
});
});
}
/**
* Creates a token from a bank account
*
* @param {?} data - The data from the bank account that should be used for the token
*
* @return {?} A promise that resolves in a token or a rejection if the creation of the token failed
*/
createTokenFromBankAccount(data) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.createToken('bank_account', data).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.token;
});
});
}
/**
* Creates a token from the personal information of a customer
*
* @param {?} data - The personal information that should be used for the creation of the token
*
* @return {?} A promise that resolves in a token or a rejection if the creation of the token failed
*/
createTokenFromPii(data) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.createToken('pii', data).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.token;
});
});
}
/**
* Creates a source object from the given element and data
*
* @param {?} element - The element from which the data needs to be extracted
* @param {?} data - An object containing the type of Source you want to create and any additional payment source information
*
* @return {?} A promise that resolves in a source object or a rejection if the creation of the source failed
*/
createSourceFromElement(element, data) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.createSource(element, data).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.source;
});
});
}
/**
* Creates a source object from only data
*
* @param {?} data - The data that should be used for the creation of the source object
*
* @return {?} A promise that resolves in a source object or a rejection if the creation of the source failed
*/
createSourceFromData(data) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.createSource(data).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.source;
});
});
}
/**
* Fetches an existing source based on the given parameters
*
* @param {?} id - The unique identifier of the source
* @param {?} client_secret - A secret available to the web client that created the Source
*
* @return {?} A promise that resolves in a source object or a rejection if the creation of the source failed
*/
getSource(id, client_secret) {
return __awaiter(this, void 0, void 0, function* () {
/** @type {?} */
const stripe = yield this.getStripe();
return stripe.retrieveSource({ id, client_secret }).then((result) => {
if (result.error) {
Promise.reject(result.error);
}
return result.source;
});
});
}
/**
* Fetches the StripeJS instance
* NOTE: Use the instance for token generation
*
* @return {?} The StripeJS instance when it is available (since StripeJS is loaded Async)
*/
getStripe() {
return this.stripe$.pipe(filter((stripe) => !!stripe), first()).toPromise().then((stripe) => stripe);
}
}
StripeService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root',
},] }
];
StripeService.ctorParameters = () => [
{ type: StripeLoader }
];
/** @nocollapse */ StripeService.ngInjectableDef = defineInjectable({ factory: function StripeService_Factory() { return new StripeService(inject(StripeLoader)); }, token: StripeService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,uselessCode} checked by tsc
*/
export { NgxStripeModule, StripeService, StripeLoader, SupportedVersions, STRIPE_OPTIONS as ɵb, STRIPE_PUBLIC_KEY as ɵa, STRIPE_VERSION as ɵc };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"secrethub-ngx-stripe.js.map","sources":["ng://@secrethub/ngx-stripe/lib/model/stripe.constant.ts","ng://@secrethub/ngx-stripe/lib/model/SupportedVersions.ts","ng://@secrethub/ngx-stripe/lib/ngx-stripe.module.ts","ng://@secrethub/ngx-stripe/lib/services/stripe-loader.service.ts","ng://@secrethub/ngx-stripe/lib/services/stripe.service.ts"],"sourcesContent":["import {InjectionToken} from '@angular/core';\nimport {SupportedVersions} from './SupportedVersions';\nimport {StripeConfigOptions} from 'stripejs';\n\n/**\n * The public key that should be used for connecting to Stripe\n */\nexport const STRIPE_PUBLIC_KEY = new InjectionToken<string>('Stripe public key');\n\n/**\n * Extra configuration options that can be used to further configure Stripe\n */\nexport const STRIPE_OPTIONS = new InjectionToken<StripeConfigOptions>('Optional configuration options');\n\n/**\n * The version of stripe that should be used\n */\nexport const STRIPE_VERSION = new InjectionToken<SupportedVersions>('Stripe version to use');\n\n/**\n * The location of the stripe javascript file\n */\nexport const STRIPE_SCRIPT_LOCATION = 'https://js.stripe.com/';\n","/**\n * All the Stripe versions that are supported by this library\n */\nexport enum SupportedVersions {\n  V3 = 'v3',\n}\n","import {ModuleWithProviders, NgModule} from '@angular/core';\r\nimport {STRIPE_OPTIONS, STRIPE_PUBLIC_KEY, STRIPE_VERSION} from './model/stripe.constant';\r\nimport {SupportedVersions} from './model/SupportedVersions';\r\nimport {StripeConfigOptions} from 'stripejs';\r\n\r\n@NgModule({\r\n  imports: [],\r\n})\r\nexport class NgxStripeModule {\r\n\r\n  /**\r\n   * Creates a new instance of the NgxStripeModule\r\n   * @param key - The public key that should be used to communicate with Stripe\r\n   * @param options - Any options to configure StripeJS\r\n   * @param [version=SupportedVersions.V3] - The version of Stripe that should be used\r\n   */\r\n  public static forRoot(key: string, options?: StripeConfigOptions, version = SupportedVersions.V3): ModuleWithProviders {\r\n    return {\r\n      ngModule: NgxStripeModule,\r\n      providers: [\r\n        {provide: STRIPE_PUBLIC_KEY, useValue: key},\r\n        {provide: STRIPE_OPTIONS, useValue: options},\r\n        {provide: STRIPE_VERSION, useValue: version},\r\n      ],\r\n    };\r\n  }\r\n}\r\n","import {Observable, Subscriber} from 'rxjs';\nimport {Inject, Injectable} from '@angular/core';\nimport {STRIPE_OPTIONS, STRIPE_PUBLIC_KEY, STRIPE_SCRIPT_LOCATION, STRIPE_VERSION} from '../model/stripe.constant';\nimport {SupportedVersions} from '../model/SupportedVersions';\nimport {StripeConfigOptions, StripeJS} from 'stripejs';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class StripeLoader {\n\n  /**\n   * The key under which the stripe script is placed in the\n   * window object\n   *\n   * @default 'Stripe'\n   */\n  private static readonly STRIPE_WINDOW_KEY = 'Stripe';\n\n  constructor(@Inject(STRIPE_VERSION) private version: SupportedVersions,\n              @Inject(STRIPE_OPTIONS) private options: StripeConfigOptions,\n              @Inject(STRIPE_PUBLIC_KEY) private key: string) {\n  }\n\n  /**\n   * Fetches the stripe instance from the DOM\n   *\n   * @return The Stripe instance or null if it is not yet registered\n   */\n  public static getStripeInstance(key: string, options: StripeConfigOptions): StripeJS | null {\n    const stripeInstance = window[StripeLoader.STRIPE_WINDOW_KEY];\n    if (stripeInstance) {\n      return stripeInstance(key, options);\n    }\n    return null;\n  }\n\n  /**\n   * Checks whether or not StripeJS has been loaded\n   */\n  public static isStripeLoaded(): boolean {\n    return !!window[StripeLoader.STRIPE_WINDOW_KEY];\n  }\n\n  /**\n   * Injects the script tag into the body of the page in order to lazy\n   * load the Stripe script\n   *\n   * @return Observable to indicate when the script has finished loading\n   */\n  public loadScript(): Observable<StripeJS> {\n    return new Observable<StripeJS>((observer: Subscriber<StripeJS>) => {\n      if (!StripeLoader.isStripeLoaded()) {\n        const script = StripeLoader.constructScript(this.getStripeScriptUrl());\n\n        script.onload = (() => {\n          observer.next(StripeLoader.getStripeInstance(this.key, this.options));\n          observer.complete();\n        });\n\n        script.onerror = () => {\n          observer.error('Failed to load the Stripe script!');\n          observer.complete();\n        };\n\n        document.body.appendChild(script);\n      } else {\n        observer.next(StripeLoader.getStripeInstance(this.key, this.options));\n        observer.complete();\n      }\n    });\n  }\n\n  /**\n   * Constructs the url that should be used for loading the Stripe script\n   * @return URL to stripe script location\n   */\n  private getStripeScriptUrl(): string {\n    return STRIPE_SCRIPT_LOCATION + this.version + '/';\n  }\n\n  /**\n   * Constructs a script element that loads javascript from the given url\n   * @param url - The URL from which the javascript should be loaded\n   *\n   * @return A script element that can be attached to the DOM\n   */\n  private static constructScript(url: string): HTMLScriptElement {\n    const script = document.createElement('script');\n    script.type = 'text/javascript';\n    script.async = true;\n    script.defer = true;\n    script.src = url;\n\n    return script;\n  }\n}\n","import {Injectable} from '@angular/core';\r\nimport {StripeJS, StripeConfigOptions} from 'stripejs';\r\nimport {StripeElement, ElementFactory, ElementCreatorOptions} from 'stripejs/element';\r\nimport {StripePaymentOptions, StripePaymentRequest} from 'stripejs/payment';\r\nimport {BankTokenData, IBANTokenData, PiiTokenData, Token, TokenData, TokenResult} from 'stripejs/token';\r\nimport {Source, SourceData, SourceResult} from 'stripejs/source';\r\nimport {BehaviorSubject, Observable} from 'rxjs';\r\nimport {filter, first} from 'rxjs/operators';\r\nimport {StripeLoader} from './stripe-loader.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class StripeService {\r\n  /**\r\n   * A BehaviorSubject containing the StripeJS object\r\n   *\r\n   * Since the script is loaded Async we need an options for all our functions\r\n   * to wait for stripe to have been loaded\r\n   */\r\n  private stripe$ = new BehaviorSubject<StripeJS | null>(null);\r\n\r\n  /**\r\n   * Lazy load the StripeJS javascript file on first usage of the service\r\n   * @param loader - The loader that should be used for loading StripeJS\r\n   */\r\n  constructor(private loader: StripeLoader) {\r\n    loader.loadScript()\r\n      .subscribe(\r\n        (stripe: StripeJS) => this.stripe$.next(stripe),\r\n        () => {\r\n          throw new Error('Stripe could not be loaded!');\r\n        },\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Creates a new stripe instance with the given key\r\n   * @param key - The public key that should be used to communicate with Stripe\r\n   * @param options - Any options to configure StripeJS\r\n   */\r\n  public changeKey(key: string, options?: StripeConfigOptions): void {\r\n    this.stripe$.next(StripeLoader.getStripeInstance(key, options));\r\n  }\r\n\r\n  /**\r\n   * Configures the `Elements` object from StripeJS with the given options\r\n   * @see https://stripe.com/docs/stripe-js/elements/quickstart#create-form\r\n   * @param [options] - Any configuration options for the Elements object\r\n   * @param [isIETFLocaleTag] - Whether or not the options `locale` is formatted as a IETFLocaleTag.\r\n   * If true the locale will be formatted by this function\r\n   *\r\n   * @return Observable that resolves in an StripeJS ElementsCreator\r\n   */\r\n  public async getElementFactory(options?: ElementCreatorOptions, isIETFLocaleTag = false): Promise<ElementFactory> {\r\n    if (isIETFLocaleTag && options && options.locale) {\r\n      options.locale = options.locale.split('-')[0]; // Only use the first part of the locale 'en' for example\r\n    }\r\n\r\n    const stripe = await this.getStripe();\r\n    return stripe.elements(options);\r\n  }\r\n\r\n  /**\r\n   * Create a payment request\r\n   * NOTE: This is NOT supported for Firefox\r\n   * @see https://stripe.com/docs/payment-request-api\r\n   *\r\n   * @param options - Payment information that should be used by Stripe\r\n   *\r\n   * @return the created request\r\n   */\r\n  public async makePaymentRequest(options: StripePaymentOptions): Promise<StripePaymentRequest> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.paymentRequest(options);\r\n  }\r\n\r\n  /**\r\n   * Creates a token from the given element\r\n   *\r\n   * @param element - The element from which the data needs to be extracted\r\n   * @param [data] - an object containing additional payment information you might have collected\r\n   *\r\n   * @return A promise that resolves in a token or a rejection if the creation of the token failed\r\n   */\r\n  public async createTokenFromElement(element: StripeElement, data?: TokenData | IBANTokenData): Promise<Token> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.createToken(element, data).then((result: TokenResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.token;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Creates a token from a bank account\r\n   *\r\n   * @param data - The data from the bank account that should be used for the token\r\n   *\r\n   * @return A promise that resolves in a token or a rejection if the creation of the token failed\r\n   */\r\n  public async createTokenFromBankAccount(data: BankTokenData): Promise<Token> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.createToken('bank_account', data).then((result: TokenResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.token;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Creates a token from the personal information of a customer\r\n   *\r\n   * @param data - The personal information that should be used for the creation of the token\r\n   *\r\n   * @return A promise that resolves in a token or a rejection if the creation of the token failed\r\n   */\r\n  public async createTokenFromPii(data: PiiTokenData): Promise<Token> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.createToken('pii', data).then((result: TokenResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.token;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Creates a source object from the given element and data\r\n   *\r\n   * @param element - The element from which the data needs to be extracted\r\n   * @param data - An object containing the type of Source you want to create and any additional payment source information\r\n   *\r\n   * @return A promise that resolves in a source object or a rejection if the creation of the source failed\r\n   */\r\n  public async createSourceFromElement(element: StripeElement, data: SourceData): Promise<Source> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.createSource(element, data).then((result: SourceResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.source;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Creates a source object from only data\r\n   *\r\n   * @param data - The data that should be used for the creation of the source object\r\n   *\r\n   * @return A promise that resolves in a source object or a rejection if the creation of the source failed\r\n   */\r\n  public async createSourceFromData(data: SourceData): Promise<Source> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.createSource(data).then((result: SourceResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.source;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Fetches an existing source based on the given parameters\r\n   *\r\n   * @param id - The unique identifier of the source\r\n   * @param client_secret - A secret available to the web client that created the Source\r\n   *\r\n   * @return A promise that resolves in a source object or a rejection if the creation of the source failed\r\n   */\r\n  public async getSource(id: string, client_secret: string): Promise<Source> {\r\n    const stripe = await this.getStripe();\r\n    return stripe.retrieveSource({id, client_secret}).then((result: SourceResult) => {\r\n      if (result.error) {\r\n        Promise.reject(result.error);\r\n      }\r\n      return result.source;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Fetches the StripeJS instance\r\n   * NOTE: Use the instance for token generation\r\n   *\r\n   * @return The StripeJS instance when it is available (since StripeJS is loaded Async)\r\n   */\r\n  private getStripe(): Promise<StripeJS> {\r\n    return this.stripe$.pipe(\r\n      filter((stripe: StripeJS | null) => !!stripe),\r\n      first(),\r\n    ).toPromise().then((stripe: StripeJS) => stripe);\r\n  }\r\n}\r\n"],"names":[],"mappings":"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"}