@lifeready/core 1.0.21 → 1.0.22

package/esm2015/lib/contact-card/contact-card2.service.js

@@ -0,0 +1,103 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable, NgZone } from '@angular/core';
+import { LrMutation } from '../api/lr-graphql';
+import { EncryptionService } from '../encryption/encryption.service';
+import { KeyFactoryService } from '../key/key-factory.service';
+import { KeyGraphService } from '../key/key-graph.service';
+import { KeyMetaService } from '../key/key-meta.service';
+import { KeyService } from '../key/key.service';
+import { RunOutsideAngular } from '../_common/run-outside-angular';
+import { CreateContactCardMutation, DeleteContactCardMutation, UpdateContactCardMutation, } from './contact-card2.gql';
+import * as i0 from "@angular/core";
+import * as i1 from "../key/key-factory.service";
+import * as i2 from "../key/key.service";
+import * as i3 from "../encryption/encryption.service";
+import * as i4 from "../key/key-graph.service";
+import * as i5 from "../key/key-meta.service";
+export class OwnerPlainDataJson {
+}
+let ContactCard2Service = class ContactCard2Service {
+    constructor(keyFactory, keyService, encryptionService, keyGraph, keyMetaService, ngZone) {
+        this.keyFactory = keyFactory;
+        this.keyService = keyService;
+        this.encryptionService = encryptionService;
+        this.keyGraph = keyGraph;
+        this.keyMetaService = keyMetaService;
+        this.ngZone = ngZone;
+    }
+    createContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const rootKey = yield this.keyService.getCurrentRootKey();
+            const key = yield this.keyFactory.createKey();
+            const wrappedKey = yield this.keyGraph.encryptToString(rootKey.jwk, key.toJSON(true));
+            const cipherData = yield this.keyGraph.encryptToString(key, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: CreateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { wrappingKeyId: rootKey.id, wrappedKey,
+                        cipherData }),
+                },
+            });
+        });
+    }
+    updateContactCard(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get encryption key
+            const cipherData = yield this.keyGraph.encryptToString(input.keyId, input.plainCipherDataJson);
+            const params = yield this.prepareContactCardInput(input);
+            return new LrMutation({
+                mutation: UpdateContactCardMutation,
+                variables: {
+                    input: Object.assign(Object.assign({}, params), { id: input.id, cipherData }),
+                },
+            });
+        });
+    }
+    deleteContactCard(id) {
+        return new LrMutation({
+            mutation: DeleteContactCardMutation,
+            variables: {
+                input: {
+                    id,
+                },
+            },
+        });
+    }
+    prepareContactCardInput(input) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sigPxk = yield this.keyService.getCurrentSigPxk();
+            const publicDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicDataJson));
+            const publicSearchableSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson));
+            const plainDataSig = JSON.stringify(yield this.encryptionService.sign(sigPxk.jwk, input.plainDataJson));
+            return {
+                sigPxkId: sigPxk.id,
+                publicDataSig,
+                publicSearchableSig,
+                plainDataSig,
+            };
+        });
+    }
+};
+ContactCard2Service.ɵprov = i0.ɵɵdefineInjectable({ factory: function ContactCard2Service_Factory() { return new ContactCard2Service(i0.ɵɵinject(i1.KeyFactoryService), i0.ɵɵinject(i2.KeyService), i0.ɵɵinject(i3.EncryptionService), i0.ɵɵinject(i4.KeyGraphService), i0.ɵɵinject(i5.KeyMetaService), i0.ɵɵinject(i0.NgZone)); }, token: ContactCard2Service, providedIn: "root" });
+ContactCard2Service.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+ContactCard2Service.ctorParameters = () => [
+    { type: KeyFactoryService },
+    { type: KeyService },
+    { type: EncryptionService },
+    { type: KeyGraphService },
+    { type: KeyMetaService },
+    { type: NgZone }
+];
+ContactCard2Service = __decorate([
+    RunOutsideAngular({
+        ngZoneName: 'ngZone',
+    })
+], ContactCard2Service);
+export { ContactCard2Service };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"contact-card2.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/contact-card/contact-card2.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone } from '@angular/core';\nimport { LrMutation } from '../api/lr-graphql';\nimport { JSONObject } from '../api/types';\nimport { EncryptionService } from '../encryption/encryption.service';\nimport { KeyFactoryService } from '../key/key-factory.service';\nimport { KeyGraphService } from '../key/key-graph.service';\nimport { KeyMetaService } from '../key/key-meta.service';\nimport { KeyService } from '../key/key.service';\nimport { MainContactCardPlainFields } from '../profile/profile.types';\nimport { RunOutsideAngular } from '../_common/run-outside-angular';\nimport {\n  CreateContactCardMutation,\n  DeleteContactCardMutation,\n  UpdateContactCardMutation,\n} from './contact-card2.gql';\n\nexport interface CreateContactCardInput2 {\n  publicDataJson: JSONObject;\n  publicSearchableJson: JSONObject;\n  plainCipherDataJson: JSONObject;\n  plainDataJson: MainContactCardPlainFields;\n}\n\n// These contact name fields are enforced by the server so that it can send out emails with\n// appropriate format.\nexport interface ContactCardName2 {\n  name: string;\n  title?: string;\n  firstName?: string;\n  lastName?: string;\n  // additional fields are not allowed by the server\n}\n\nexport class OwnerPlainDataJson {\n  name: ContactCardName2;\n}\n\nexport interface UpdateContactCardInput2 extends CreateContactCardInput2 {\n  id: string;\n  keyId: string;\n}\n\n@RunOutsideAngular({\n  ngZoneName: 'ngZone',\n})\n@Injectable({\n  providedIn: 'root',\n})\nexport class ContactCard2Service {\n  constructor(\n    private keyFactory: KeyFactoryService,\n    private keyService: KeyService,\n    private encryptionService: EncryptionService,\n    private keyGraph: KeyGraphService,\n    private keyMetaService: KeyMetaService,\n    private ngZone: NgZone\n  ) {}\n\n  async createContactCard(input: CreateContactCardInput2) {\n    // Get encryption key\n    const rootKey = await this.keyService.getCurrentRootKey();\n    const key = await this.keyFactory.createKey();\n    const wrappedKey = await this.keyGraph.encryptToString(\n      rootKey.jwk,\n      key.toJSON(true)\n    );\n    const cipherData = await this.keyGraph.encryptToString(\n      key,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: CreateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          wrappingKeyId: rootKey.id,\n          wrappedKey,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  async updateContactCard(input: UpdateContactCardInput2) {\n    // Get encryption key\n    const cipherData = await this.keyGraph.encryptToString(\n      input.keyId,\n      input.plainCipherDataJson\n    );\n\n    const params = await this.prepareContactCardInput(input);\n\n    return new LrMutation({\n      mutation: UpdateContactCardMutation,\n      variables: {\n        input: {\n          ...params,\n          id: input.id,\n          cipherData,\n        },\n      },\n    });\n  }\n\n  deleteContactCard(id: string) {\n    return new LrMutation({\n      mutation: DeleteContactCardMutation,\n      variables: {\n        input: {\n          id,\n        },\n      },\n    });\n  }\n\n  private async prepareContactCardInput(\n    input: CreateContactCardInput2\n  ): Promise<any> {\n    const sigPxk = await this.keyService.getCurrentSigPxk();\n    const publicDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicDataJson)\n    );\n    const publicSearchableSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.publicSearchableJson)\n    );\n    const plainDataSig = JSON.stringify(\n      await this.encryptionService.sign(sigPxk.jwk, input.plainDataJson)\n    );\n\n    return {\n      sigPxkId: sigPxk.id,\n      publicDataSig,\n      publicSearchableSig,\n      plainDataSig,\n    };\n  }\n}\n"]}

package/esm2015/lib/encryption/encryption.service.js

@@ -0,0 +1,189 @@
+import { __awaiter } from "tslib";
+import { Injectable } from '@angular/core';
+import { JWE, JWS } from 'node-jose';
+import { TimeService } from '../time/time.service';
+import { LrBadArgumentException, LrErrorCode, LrException, } from './../_common/exceptions';
+import * as i0 from "@angular/core";
+import * as i1 from "../time/time.service";
+export var JoseSerialization;
+(function (JoseSerialization) {
+    JoseSerialization["JSON"] = "JSON";
+    JoseSerialization["COMPACT"] = "COMPACT";
+})(JoseSerialization || (JoseSerialization = {}));
+export const VERIFY_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+};
+export const DECRYPT_OPTIONS_DEFAULT = {
+    payloadType: 'json',
+    returnOnlyPayload: true,
+    serializations: [JoseSerialization.JSON],
+};
+export function isSymmetricKey(key) {
+    // TODO: make sure this covers all cases.
+    return key.kty === 'oct';
+}
+export function asJwk(key) {
+    // TODO: make sure this covers all cases.
+    // Excluded:
+    //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2
+    if (key.id && key.jwk) {
+        return key.jwk;
+    }
+    else if (key.keystore && key.length && key.kty && key.kid && key.alg) {
+        return key;
+    }
+    else {
+        return null;
+    }
+}
+export class EncryptionService {
+    constructor(timeService) {
+        this.timeService = timeService;
+    }
+    decrypt(key, // string is assumed to be key.id, will unwrap key.
+    jwe, // string will be JSON.parsed
+    options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],
+            };
+            options = Object.assign(Object.assign({}, DECRYPT_OPTIONS_DEFAULT), options);
+            if (key.jwk) {
+                key = key.jwk;
+            }
+            if (typeof jwe === 'string') {
+                if (options.serializations.includes(JoseSerialization.JSON)) {
+                    try {
+                        jwe = JSON.parse(jwe);
+                    }
+                    catch (error) {
+                        if (options.serializations.includes(JoseSerialization.COMPACT)) {
+                            console.log('Not a JSON-formatted JWE, it maybe compact serialisation format.');
+                        }
+                        else {
+                            throw error;
+                        }
+                    }
+                }
+            }
+            // {result} is a Object with:
+            // *  header: the combined 'protected' and 'unprotected' header members
+            // *  protected: an array of the member names from the "protected" member
+            // *  key: Key used to decrypt
+            // *  payload: Buffer of the decrypted content
+            // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload
+            const res = yield JWE.createDecrypt(key, opt).decrypt(jwe);
+            res.payload = this.decodePayload(options.payloadType, res.payload);
+            if (options.returnOnlyPayload) {
+                return res.payload;
+            }
+            else {
+                return res;
+            }
+        });
+    }
+    // TODO rename this to encrypt() and use as the most common usecase
+    encryptToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.encrypt(key, content));
+        });
+    }
+    // TODO rename this to encryptToJSON() and use this when required.
+    encrypt(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (content == null) {
+                throw new Error('Encrypting null/undefined content.');
+            }
+            if (!(content instanceof ArrayBuffer)) {
+                content = new TextEncoder().encode(JSON.stringify(content));
+            }
+            return JWE.createEncrypt({
+                contentAlg: 'A256GCM',
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key)
+                .update(content)
+                .final();
+        });
+    }
+    // <AZ> Unlike signContent, the serialised "content" variable is contained inside
+    // the result. So ordering of fields within "content" is not an issue.
+    sign(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = JWS.createSign({
+                fields: {
+                    timestamp: yield this.timeService.serverNow(),
+                },
+            }, key);
+            if (content instanceof Buffer) {
+                signer.update(content);
+            }
+            else {
+                signer.update(JSON.stringify(content), 'utf8');
+            }
+            return signer.final();
+        });
+    }
+    signToString(key, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.sign(key, content));
+        });
+    }
+    verify(key, jws, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const opt = {
+                algorithms: ['RS*'],
+            };
+            options = Object.assign(Object.assign({}, VERIFY_OPTIONS_DEFAULT), options);
+            try {
+                const res = yield JWS.createVerify(key, opt).verify(jws);
+                res.payload = this.decodePayload(options.payloadType, res.payload);
+                if (options.returnOnlyPayload) {
+                    return res.payload;
+                }
+                else {
+                    return res;
+                }
+            }
+            catch (error) {
+                throw new LrException({
+                    code: LrErrorCode.BadSignature,
+                    message: `Bad signature: ${error}`,
+                });
+            }
+        });
+    }
+    encryptThenSign({ key, sigPrk, }, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cipher = JSON.stringify(yield this.encrypt(key, content));
+            const sig = yield this.sign(sigPrk, cipher);
+            delete sig.payload;
+            return {
+                cipher,
+                sig: JSON.stringify(sig),
+            };
+        });
+    }
+    decodePayload(payloadType, payload) {
+        switch (payloadType) {
+            case 'json':
+                return JSON.parse(new TextDecoder().decode(payload));
+            case 'ArrayBuffer':
+                return payload;
+            default:
+                throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);
+        }
+    }
+}
+EncryptionService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EncryptionService_Factory() { return new EncryptionService(i0.ɵɵinject(i1.TimeService)); }, token: EncryptionService, providedIn: "root" });
+EncryptionService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+EncryptionService.ctorParameters = () => [
+    { type: TimeService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/encryption/encryption.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { JWE, JWK, JWS } from 'node-jose';\nimport { Key, PayloadType } from '../key/key.types';\nimport { TimeService } from '../time/time.service';\nimport {\n  LrBadArgumentException,\n  LrErrorCode,\n  LrException,\n} from './../_common/exceptions';\n\nexport enum JoseSerialization {\n  JSON = 'JSON',\n  COMPACT = 'COMPACT',\n}\n\nexport interface VerifyOptions {\n  payloadType?: PayloadType;\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\n}\n\nexport interface DecryptOptions {\n  payloadType?: PayloadType;\n  returnOnlyPayload?: boolean; // If true, return only the decoded payload.\n  serializations?: JoseSerialization[];\n}\n\nexport const VERIFY_OPTIONS_DEFAULT: VerifyOptions = {\n  payloadType: 'json',\n  returnOnlyPayload: true,\n};\n\nexport const DECRYPT_OPTIONS_DEFAULT: DecryptOptions = {\n  payloadType: 'json',\n  returnOnlyPayload: true,\n  serializations: [JoseSerialization.JSON],\n};\n\nexport function isSymmetricKey(key: JWK.Key) {\n  // TODO: make sure this covers all cases.\n  return key.kty === 'oct';\n}\n\nexport function asJwk(key: JWK.Key | Key | any): JWK.Key | null {\n  // TODO: make sure this covers all cases.\n  // Excluded:\n  //   key.use - only for public keys, Ref: https://tools.ietf.org/html/rfc7517#section-4.2\n\n  if (key.id && key.jwk) {\n    return key.jwk;\n  } else if (key.keystore && key.length && key.kty && key.kid && key.alg) {\n    return key;\n  } else {\n    return null;\n  }\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class EncryptionService {\n  constructor(private timeService: TimeService) {}\n\n  async decrypt(\n    key: JWK.Key | Key, // string is assumed to be key.id, will unwrap key.\n    jwe: object | string, // string will be JSON.parsed\n    options?: DecryptOptions\n  ): Promise<JWE.DecryptResult | any> {\n    const opt = {\n      algorithms: ['dir', 'A*GCM', 'RSA-OAEP-*'],\n    };\n\n    options = {\n      ...DECRYPT_OPTIONS_DEFAULT,\n      ...options,\n    };\n\n    if ((key as Key).jwk) {\n      key = (key as Key).jwk;\n    }\n\n    if (typeof jwe === 'string') {\n      if (options.serializations.includes(JoseSerialization.JSON)) {\n        try {\n          jwe = JSON.parse(jwe);\n        } catch (error) {\n          if (options.serializations.includes(JoseSerialization.COMPACT)) {\n            console.log(\n              'Not a JSON-formatted JWE, it maybe compact serialisation format.'\n            );\n          } else {\n            throw error;\n          }\n        }\n      }\n    }\n\n    // {result} is a Object with:\n    // *  header: the combined 'protected' and 'unprotected' header members\n    // *  protected: an array of the member names from the \"protected\" member\n    // *  key: Key used to decrypt\n    // *  payload: Buffer of the decrypted content\n    // *  plaintext: Buffer of the decrypted content (alternate), just a reference to payload\n    const res = await JWE.createDecrypt(key as JWK.Key, opt).decrypt(\n      jwe as any\n    );\n\n    res.payload = this.decodePayload(options.payloadType, res.payload);\n\n    if (options.returnOnlyPayload) {\n      return res.payload;\n    } else {\n      return res;\n    }\n  }\n\n  // TODO rename this to encrypt() and use as the most common usecase\n  async encryptToString(\n    key: JWK.Key,\n    content: ArrayBuffer | string | object\n  ): Promise<string> {\n    return JSON.stringify(await this.encrypt(key, content));\n  }\n\n  // TODO rename this to encryptToJSON() and use this when required.\n  async encrypt(\n    key: JWK.Key,\n    content: ArrayBuffer | string | object\n  ): Promise<any> {\n    if (content == null) {\n      throw new Error('Encrypting null/undefined content.');\n    }\n\n    if (!(content instanceof ArrayBuffer)) {\n      content = new TextEncoder().encode(JSON.stringify(content));\n    }\n\n    return JWE.createEncrypt(\n      {\n        contentAlg: 'A256GCM',\n        fields: {\n          timestamp: await this.timeService.serverNow(),\n        },\n      } as any,\n      key\n    )\n      .update(content)\n      .final() as any;\n  }\n\n  // <AZ> Unlike signContent, the serialised \"content\" variable is contained inside\n  // the result. So ordering of fields within \"content\" is not an issue.\n  async sign(key: JWK.Key, content: Buffer | string | object): Promise<any> {\n    const signer = JWS.createSign(\n      {\n        fields: {\n          timestamp: await this.timeService.serverNow(),\n        },\n      },\n      key\n    );\n\n    if (content instanceof Buffer) {\n      signer.update(content);\n    } else {\n      signer.update(JSON.stringify(content), 'utf8');\n    }\n\n    return signer.final();\n  }\n\n  async signToString(\n    key: JWK.Key,\n    content: Buffer | string | object\n  ): Promise<string> {\n    return JSON.stringify(await this.sign(key, content));\n  }\n\n  async verify(\n    key: JWK.Key,\n    jws: object,\n    options?: VerifyOptions\n  ): Promise<any> {\n    const opt = {\n      algorithms: ['RS*'],\n    };\n\n    options = {\n      ...VERIFY_OPTIONS_DEFAULT,\n      ...options,\n    };\n\n    try {\n      const res = await JWS.createVerify(key, opt).verify(jws as any);\n\n      res.payload = this.decodePayload(options.payloadType, res.payload);\n\n      if (options.returnOnlyPayload) {\n        return res.payload;\n      } else {\n        return res;\n      }\n    } catch (error) {\n      throw new LrException({\n        code: LrErrorCode.BadSignature,\n        message: `Bad signature: ${error}`,\n      });\n    }\n  }\n\n  async encryptThenSign(\n    {\n      key,\n      sigPrk,\n    }: {\n      key: JWK.Key;\n      sigPrk: JWK.Key;\n    },\n    content: ArrayBuffer | string | object\n  ): Promise<{ cipher: string; sig: string }> {\n    const cipher = JSON.stringify(await this.encrypt(key, content));\n    const sig = await this.sign(sigPrk, cipher);\n    delete sig.payload;\n\n    return {\n      cipher,\n      sig: JSON.stringify(sig),\n    };\n  }\n\n  private decodePayload(\n    payloadType: PayloadType,\n    payload: ArrayBuffer\n  ): ArrayBuffer | any {\n    switch (payloadType) {\n      case 'json':\n        return JSON.parse(new TextDecoder().decode(payload));\n      case 'ArrayBuffer':\n        return payload;\n      default:\n        throw new LrBadArgumentException(`Unknown payloadType: ${payloadType}`);\n    }\n  }\n}\n"]}

package/esm2015/lib/file-upload/file-upload.service.js

@@ -0,0 +1,74 @@
+import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
+import { Inject, Injectable } from '@angular/core';
+import { LifeReadyAuthService } from '../auth/life-ready-auth.service';
+import { LR_CONFIG } from '../life-ready.config';
+import * as i0 from "@angular/core";
+import * as i1 from "../life-ready.config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../auth/life-ready-auth.service";
+export class FileUploadService {
+    constructor(config, http, lrAuth) {
+        this.config = config;
+        this.http = http;
+        this.lrAuth = lrAuth;
+    }
+    downloadEncryptedFile(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.parse(yield this.downloadEncryptedFile2(fileStateNodeId));
+        });
+    }
+    downloadEncryptedFile2(fileStateNodeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const url = `${this.config.apiUrl}files/download/?file_state_node_id=${fileStateNodeId}`;
+            const content = yield this.http
+                .get(url, {
+                responseType: 'text',
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content;
+        });
+    }
+    loadFile(file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => {
+                    // OK to type cast here since we are using readAsArrayBuffer.
+                    resolve(reader.result);
+                };
+                reader.readAsArrayBuffer(file);
+            });
+        });
+    }
+    uploadEncryptedFile(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { encryptedContent, fileName } = options;
+            const formData = new FormData();
+            formData.append('content', new Blob([encryptedContent]), fileName);
+            const { content_resource } = yield this.http
+                .post(`${this.config.apiUrl}files/upload/`, formData, {
+                headers: {
+                    Authorization: `Bearer ${(yield this.lrAuth.getUser()).getAccessJwtToken()}`,
+                },
+            })
+                .toPromise();
+            return content_resource;
+        });
+    }
+}
+FileUploadService.ɵprov = i0.ɵɵdefineInjectable({ factory: function FileUploadService_Factory() { return new FileUploadService(i0.ɵɵinject(i1.LR_CONFIG), i0.ɵɵinject(i2.HttpClient), i0.ɵɵinject(i3.LifeReadyAuthService)); }, token: FileUploadService, providedIn: "root" });
+FileUploadService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root',
+            },] }
+];
+FileUploadService.ctorParameters = () => [
+    { type: undefined, decorators: [{ type: Inject, args: [LR_CONFIG,] }] },
+    { type: HttpClient },
+    { type: LifeReadyAuthService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/file-upload/file-upload.types.js

@@ -0,0 +1 @@
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiL29wdC9hdGxhc3NpYW4vcGlwZWxpbmVzL2FnZW50L2J1aWxkL3Byb2plY3RzL2NvcmUvc3JjLyIsInNvdXJjZXMiOlsibGliL2ZpbGUtdXBsb2FkL2ZpbGUtdXBsb2FkLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgdHlwZSBGaWxlQ29udGVudENvbnRleHQgPSAnRklMRV9TVEFURSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgVXBsb2FkRW5jcnlwdGVkRmlsZU9wdGlvbnMge1xuICBlbmNyeXB0ZWRDb250ZW50OiBzdHJpbmc7XG4gIC8vIFRPRE8gQWRkIGluIHRoZSBjb250ZXh0IGZpZWxkIGFuZCBtYWtlIGl0IG1hbmRhdG9yeVxuICAvLyBjb250ZXh0OiBGaWxlQ29udGVudENvbnRleHQ7XG4gIGZpbGVOYW1lPzogc3RyaW5nO1xufVxuIl19

package/esm2015/lib/{auth → idle}/idle.service.js

@@ -1,19 +1,19 @@
 import { __awaiter } from "tslib";
+import { HttpClient } from '@angular/common/http';
 import { Inject, Injectable } from '@angular/core';
-import { Idle, DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';
+import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
+import { DEFAULT_INTERRUPTSOURCES, Idle } from '@ng-idle/core';
 import { Keepalive } from '@ng-idle/keepalive';
-import { KeyService } from '../cryptography/key.service';
-import { LrBadArgumentException, LrBadStateException, } from '../_common/exceptions';
+import { KeyService } from '../key/key.service';
 import { LR_CONFIG } from '../life-ready.config';
-import { HttpClient } from '@angular/common/http';
+import { LrBadArgumentException, LrBadStateException, } from '../_common/exceptions';
 import { Config } from './idle.types';
-import { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';
 import * as i0 from "@angular/core";
 import * as i1 from "../life-ready.config";
 import * as i2 from "@angular/common/http";
 import * as i3 from "@ng-idle/core";
 import * as i4 from "@ng-idle/keepalive";
-import * as i5 from "../cryptography/key.service";
+import * as i5 from "../key/key.service";
 import * as i6 from "@aws-amplify/auth/lib-esm/Auth";
 export class IdleService {
     constructor(config, http, idle, keepalive, keyService, auth) {
@@ -165,4 +165,4 @@ IdleService.ctorParameters = () => [
     { type: KeyService },
     { type: AuthClass }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/auth/idle.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\nimport { Idle, DEFAULT_INTERRUPTSOURCES } from '@ng-idle/core';\nimport { Keepalive } from '@ng-idle/keepalive';\nimport { KeyService } from '../cryptography/key.service';\nimport {\n  LrBadArgumentException,\n  LrBadStateException,\n} from '../_common/exceptions';\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\nimport { HttpClient } from '@angular/common/http';\nimport { Config, KeepaliveResult } from './idle.types';\nimport { Key } from '../cryptography/cryptography.types';\nimport { CognitoUser } from '@aws-amplify/auth';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\n\nexport interface IdleServiceInit {\n  // TODO: this should be EventEmitter instead of a callback.\n  onTimeout?: (() => any) | (() => Promise<any>) | null;\n  onKeepalive?: (() => any) | (() => Promise<any>) | null;\n  idleSec?: number;\n  timeoutSec?: number;\n  keepAliveIntervalSec?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IdleService {\n  private readonly IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';\n  private readonly IDLING_KEY = 'ng2Idle.main.idling';\n\n  private initCalled = false;\n  private onTimeout: (() => any) | (() => Promise<any>) | null;\n  private onKeepalive: (() => any) | (() => Promise<any>) | null;\n\n  constructor(\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\n    private http: HttpClient,\n    private idle: Idle,\n    private keepalive: Keepalive,\n    private keyService: KeyService,\n    private auth: AuthClass\n  ) {}\n\n  private assertInit(): void {\n    if (!this.initCalled) {\n      throw new LrBadStateException('Call IdleService.init() first.');\n    }\n  }\n\n  public async init(params?: IdleServiceInit): Promise<void> {\n    if (this.initCalled) {\n      throw new LrBadStateException(\n        'IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.'\n      );\n    }\n\n    this.initCalled = true;\n\n    // Defaults\n    params = {\n      onTimeout: null,\n      onKeepalive: null,\n      idleSec: Config.IDLE,\n      timeoutSec: Config.TIMEOUT,\n      keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL,\n      ...params,\n    };\n\n    // If timeoutSec == 0 then the onTimeout() callback is never called.\n    if (params.timeoutSec < 0.01) {\n      throw new LrBadArgumentException(\n        'Minimum value for IdleService.init({ timeoutSec }) is 0.01'\n      );\n    }\n\n    this.onTimeout = params.onTimeout;\n    this.onKeepalive = params.onKeepalive;\n\n    // ------------------------------------------------------------------------\n    // Setup Idle\n    // ------------------------------------------------------------------------\n    // sets an idle timeout of 5 seconds, for testing purposes.\n    this.idle.setIdle(params.idleSec);\n    // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.\n    this.idle.setTimeout(params.timeoutSec);\n    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document\n    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);\n\n    this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));\n    this.idle.onIdleStart.subscribe(() => console.log('Idle started'));\n\n    this.idle.onTimeout.subscribe(async () => {\n      console.log('Idle timed out');\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    });\n    this.idle.onTimeoutWarning.subscribe((countdown: any) =>\n      console.log(`Will timeout in ${countdown} seconds!`)\n    );\n\n    // ------------------------------------------------------------------------\n    // Setup Keepalive\n    // ------------------------------------------------------------------------\n    // Ref: https://github.com/moribvndvs/ng2-idle#readme\n    // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once\n    // they go idle or time out. When the user resumes activity or the idle state is reset, it will\n    // ping immediately and then resume pinging.\n    this.keepalive.interval(params.keepAliveIntervalSec);\n    console.log(\n      `Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`\n    );\n\n    this.keepalive.onPing.subscribe(() => this.onPing());\n\n    // If the browser tab has been closed for a period longer thant the inactivity\n    // period, then we should logout right from the start.\n    const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);\n    if (\n      idleExpiry &&\n      parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()\n    ) {\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    }\n  }\n\n  public async keepalivePost(): Promise<{\n    expiresAfterSeconds: number;\n    keepaliveResult: KeepaliveResult;\n  }> {\n    // currentAuthenticatedUser() refreshes the access token if required.\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\n\n    const keepaliveResult = await this.http\n      .post<KeepaliveResult>(`${this.config.authUrl}auth/keepalive/`, null, {\n        withCredentials: true, // /auth/keepalive/ will be extending the sessions cookie.\n        headers: {\n          Authorization: `Bearer ${cognitoUser\n            .getSignInUserSession()\n            .getAccessToken()\n            .getJwtToken()}`,\n        },\n      })\n      .toPromise();\n\n    return {\n      keepaliveResult,\n      expiresAfterSeconds:\n        this.idle.getIdle() +\n        this.idle.getTimeout() +\n        this.keepalive.interval(),\n    };\n  }\n\n  public async persistMasterKey(masterKey: Key): Promise<void> {\n    // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie\n    // expiry, and returns the session expiry.\n    // NOTE Use time delta rather than absolute time, since client clock and server clock maybe\n    // out of sync. We can't use the serverTime() functionality because the cookie expiry still\n    // run on local clock.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Persist the derived passKey\n    await this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);\n\n    console.log('setMasterKey() done');\n  }\n\n  private async onPing(): Promise<void> {\n    console.log(\n      `Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`\n    );\n\n    // Keepalive API will extend the session expiry.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Extend the expiry of the persisted key\n    await this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);\n\n    await Promise.resolve(this.onKeepalive && this.onKeepalive());\n  }\n\n  public async start(): Promise<void> {\n    if (!this.initCalled) {\n      await this.init();\n    }\n\n    if (this.idle.isRunning()) {\n      return;\n    }\n\n    // Ping does not seem to happen right at the start. So we call it explicitly\n    await this.onPing();\n\n    this.idle.watch();\n  }\n\n  public stop(): void {\n    this.idle.stop();\n    this.reset();\n  }\n\n  private reset() {\n    localStorage.removeItem(this.IDLE_EXPIRY_KEY);\n    localStorage.removeItem(this.IDLING_KEY);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"idle.service.js","sourceRoot":"/opt/atlassian/pipelines/agent/build/projects/core/src/","sources":["lib/idle/idle.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient } from '@angular/common/http';\nimport { Inject, Injectable } from '@angular/core';\nimport { CognitoUser } from '@aws-amplify/auth';\nimport { AuthClass } from '@aws-amplify/auth/lib-esm/Auth';\nimport { DEFAULT_INTERRUPTSOURCES, Idle } from '@ng-idle/core';\nimport { Keepalive } from '@ng-idle/keepalive';\nimport { KeyService } from '../key/key.service';\nimport { Key } from '../key/key.types';\nimport { LifeReadyConfig, LR_CONFIG } from '../life-ready.config';\nimport {\n  LrBadArgumentException,\n  LrBadStateException,\n} from '../_common/exceptions';\nimport { Config, KeepaliveResult } from './idle.types';\n\nexport interface IdleServiceInit {\n  // TODO: this should be EventEmitter instead of a callback.\n  onTimeout?: (() => any) | (() => Promise<any>) | null;\n  onKeepalive?: (() => any) | (() => Promise<any>) | null;\n  idleSec?: number;\n  timeoutSec?: number;\n  keepAliveIntervalSec?: number;\n}\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class IdleService {\n  private readonly IDLE_EXPIRY_KEY = 'ng2Idle.main.expiry';\n  private readonly IDLING_KEY = 'ng2Idle.main.idling';\n\n  private initCalled = false;\n  private onTimeout: (() => any) | (() => Promise<any>) | null;\n  private onKeepalive: (() => any) | (() => Promise<any>) | null;\n\n  constructor(\n    @Inject(LR_CONFIG) private config: LifeReadyConfig,\n    private http: HttpClient,\n    private idle: Idle,\n    private keepalive: Keepalive,\n    private keyService: KeyService,\n    private auth: AuthClass\n  ) {}\n\n  private assertInit(): void {\n    if (!this.initCalled) {\n      throw new LrBadStateException('Call IdleService.init() first.');\n    }\n  }\n\n  public async init(params?: IdleServiceInit): Promise<void> {\n    if (this.initCalled) {\n      throw new LrBadStateException(\n        'IdleService.init() can only be called once. IdleService.start() calls init() with default values if init() has not been called yet.'\n      );\n    }\n\n    this.initCalled = true;\n\n    // Defaults\n    params = {\n      onTimeout: null,\n      onKeepalive: null,\n      idleSec: Config.IDLE,\n      timeoutSec: Config.TIMEOUT,\n      keepAliveIntervalSec: Config.KEEP_ALIVE_INTERVAL,\n      ...params,\n    };\n\n    // If timeoutSec == 0 then the onTimeout() callback is never called.\n    if (params.timeoutSec < 0.01) {\n      throw new LrBadArgumentException(\n        'Minimum value for IdleService.init({ timeoutSec }) is 0.01'\n      );\n    }\n\n    this.onTimeout = params.onTimeout;\n    this.onKeepalive = params.onKeepalive;\n\n    // ------------------------------------------------------------------------\n    // Setup Idle\n    // ------------------------------------------------------------------------\n    // sets an idle timeout of 5 seconds, for testing purposes.\n    this.idle.setIdle(params.idleSec);\n    // sets a timeout period of 5 seconds. after 10 seconds of inactivity, the user will be considered timed out.\n    this.idle.setTimeout(params.timeoutSec);\n    // sets the default interrupts, in this case, things like clicks, scrolls, touches to the document\n    this.idle.setInterrupts(DEFAULT_INTERRUPTSOURCES);\n\n    this.idle.onIdleEnd.subscribe(() => console.log('Idle stopped'));\n    this.idle.onIdleStart.subscribe(() => console.log('Idle started'));\n\n    this.idle.onTimeout.subscribe(async () => {\n      console.log('Idle timed out');\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    });\n    this.idle.onTimeoutWarning.subscribe((countdown: any) =>\n      console.log(`Will timeout in ${countdown} seconds!`)\n    );\n\n    // ------------------------------------------------------------------------\n    // Setup Keepalive\n    // ------------------------------------------------------------------------\n    // Ref: https://github.com/moribvndvs/ng2-idle#readme\n    // ng-idle will instruct @ng-idle/keepalive to ping while the user is active, and stop once\n    // they go idle or time out. When the user resumes activity or the idle state is reset, it will\n    // ping immediately and then resume pinging.\n    this.keepalive.interval(params.keepAliveIntervalSec);\n    console.log(\n      `Keep alive interval set at: ${Config.KEEP_ALIVE_INTERVAL} seconds`\n    );\n\n    this.keepalive.onPing.subscribe(() => this.onPing());\n\n    // If the browser tab has been closed for a period longer thant the inactivity\n    // period, then we should logout right from the start.\n    const idleExpiry = localStorage.getItem(this.IDLE_EXPIRY_KEY);\n    if (\n      idleExpiry &&\n      parseInt(idleExpiry, 10) + this.idle.getTimeout() * 1000 < Date.now()\n    ) {\n      this.reset();\n      await Promise.resolve(this.onTimeout && this.onTimeout());\n    }\n  }\n\n  public async keepalivePost(): Promise<{\n    expiresAfterSeconds: number;\n    keepaliveResult: KeepaliveResult;\n  }> {\n    // currentAuthenticatedUser() refreshes the access token if required.\n    const cognitoUser: CognitoUser = await this.auth.currentAuthenticatedUser();\n\n    const keepaliveResult = await this.http\n      .post<KeepaliveResult>(`${this.config.authUrl}auth/keepalive/`, null, {\n        withCredentials: true, // /auth/keepalive/ will be extending the sessions cookie.\n        headers: {\n          Authorization: `Bearer ${cognitoUser\n            .getSignInUserSession()\n            .getAccessToken()\n            .getJwtToken()}`,\n        },\n      })\n      .toPromise();\n\n    return {\n      keepaliveResult,\n      expiresAfterSeconds:\n        this.idle.getIdle() +\n        this.idle.getTimeout() +\n        this.keepalive.interval(),\n    };\n  }\n\n  public async persistMasterKey(masterKey: Key): Promise<void> {\n    // The keepalive API call extends the server-side session, the session cookie expiry, refresh key cookie\n    // expiry, and returns the session expiry.\n    // NOTE Use time delta rather than absolute time, since client clock and server clock maybe\n    // out of sync. We can't use the serverTime() functionality because the cookie expiry still\n    // run on local clock.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Persist the derived passKey\n    await this.keyService.persistMasterKey(masterKey, expiresAfterSeconds);\n\n    console.log('setMasterKey() done');\n  }\n\n  private async onPing(): Promise<void> {\n    console.log(\n      `Keep alive triggered at time: ${Date.now()}. Interval set at: ${this.keepalive.interval()} seconds`\n    );\n\n    // Keepalive API will extend the session expiry.\n    const { expiresAfterSeconds } = await this.keepalivePost();\n\n    // Extend the expiry of the persisted key\n    await this.keyService.setMasterKeyExpiresAfterSeconds(expiresAfterSeconds);\n\n    await Promise.resolve(this.onKeepalive && this.onKeepalive());\n  }\n\n  public async start(): Promise<void> {\n    if (!this.initCalled) {\n      await this.init();\n    }\n\n    if (this.idle.isRunning()) {\n      return;\n    }\n\n    // Ping does not seem to happen right at the start. So we call it explicitly\n    await this.onPing();\n\n    this.idle.watch();\n  }\n\n  public stop(): void {\n    this.idle.stop();\n    this.reset();\n  }\n\n  private reset() {\n    localStorage.removeItem(this.IDLE_EXPIRY_KEY);\n    localStorage.removeItem(this.IDLING_KEY);\n  }\n}\n"]}

package/esm2015/lib/{auth → idle}/idle.types.js

@@ -4,4 +4,4 @@ export var Config;
     Config[Config["IDLE"] = 1200] = "IDLE";
     Config[Config["KEEP_ALIVE_INTERVAL"] = 60] = "KEEP_ALIVE_INTERVAL";
 })(Config || (Config = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRsZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIvb3B0L2F0bGFzc2lhbi9waXBlbGluZXMvYWdlbnQvYnVpbGQvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvYXV0aC9pZGxlLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLE1BSVg7QUFKRCxXQUFZLE1BQU07SUFDaEIsNENBQWMsQ0FBQTtJQUNkLHNDQUFjLENBQUE7SUFDZCxrRUFBNEIsQ0FBQTtBQUM5QixDQUFDLEVBSlcsTUFBTSxLQUFOLE1BQU0sUUFJakIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBDb25maWcge1xuICBUSU1FT1VUID0gMC4wMSwgLy8gc2Vjb25kcywgbWluIHZhbHVlIDAuMDEsIGFmdGVyIHN0YXRlIGlzIGlkbGUsIHdhaXQgZm9yIFRJTUVPVVQgc2Vjb25kcyBiZWZvcmUgdGFraW5nIGFjdGlvblxuICBJRExFID0gNjAgKiAyMCwgLy8gc2Vjb25kcywgcGVyaW9kIG9mIGluYWN0aXZpdHkgdG8gY29uc2lkZXIgc3RhdGUgYXMgaWRsZVxuICBLRUVQX0FMSVZFX0lOVEVSVkFMID0gNjAgKiAxLCAvLyBzZWNvbmRzLCB0cmlnZ2VyZWQgb24gYSByZWd1bGFyIGJhc2lzIHdoaWxlIGFjdGl2ZSAoaS5lLiB3aGlsZSBub3QgaWRsaW5nKVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIEtlZXBhbGl2ZVJlc3VsdCB7XG4gIHNlc3Npb246IHtcbiAgICBleHBpcmVzX2FmdGVyX3NlY29uZHM6IG51bWJlcjtcbiAgfTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWRsZS50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIvb3B0L2F0bGFzc2lhbi9waXBlbGluZXMvYWdlbnQvYnVpbGQvcHJvamVjdHMvY29yZS9zcmMvIiwic291cmNlcyI6WyJsaWIvaWRsZS9pZGxlLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLE1BSVg7QUFKRCxXQUFZLE1BQU07SUFDaEIsNENBQWMsQ0FBQTtJQUNkLHNDQUFjLENBQUE7SUFDZCxrRUFBNEIsQ0FBQTtBQUM5QixDQUFDLEVBSlcsTUFBTSxLQUFOLE1BQU0sUUFJakIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBDb25maWcge1xuICBUSU1FT1VUID0gMC4wMSwgLy8gc2Vjb25kcywgbWluIHZhbHVlIDAuMDEsIGFmdGVyIHN0YXRlIGlzIGlkbGUsIHdhaXQgZm9yIFRJTUVPVVQgc2Vjb25kcyBiZWZvcmUgdGFraW5nIGFjdGlvblxuICBJRExFID0gNjAgKiAyMCwgLy8gc2Vjb25kcywgcGVyaW9kIG9mIGluYWN0aXZpdHkgdG8gY29uc2lkZXIgc3RhdGUgYXMgaWRsZVxuICBLRUVQX0FMSVZFX0lOVEVSVkFMID0gNjAgKiAxLCAvLyBzZWNvbmRzLCB0cmlnZ2VyZWQgb24gYSByZWd1bGFyIGJhc2lzIHdoaWxlIGFjdGl2ZSAoaS5lLiB3aGlsZSBub3QgaWRsaW5nKVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIEtlZXBhbGl2ZVJlc3VsdCB7XG4gIHNlc3Npb246IHtcbiAgICBleHBpcmVzX2FmdGVyX3NlY29uZHM6IG51bWJlcjtcbiAgfTtcbn1cbiJdfQ==