ngx-toastr 16.1.1 → 17.0.0

package/esm2022/toastr/toast-noanimation.component.mjs

@@ -0,0 +1,253 @@
+import { NgIf } from '@angular/common';
+import { Component, HostBinding, HostListener, NgModule, } from '@angular/core';
+import { DefaultNoComponentGlobalConfig, TOAST_CONFIG, } from './toastr-config';
+import * as i0 from "@angular/core";
+import * as i1 from "./toastr.service";
+import * as i2 from "./toastr-config";
+class ToastNoAnimation {
+    toastrService;
+    toastPackage;
+    appRef;
+    message;
+    title;
+    options;
+    duplicatesCount;
+    originalTimeout;
+    /** width of progress bar */
+    width = -1;
+    /** a combination of toast type and options.toastClass */
+    toastClasses = '';
+    /** hides component when waiting to be displayed */
+    get displayStyle() {
+        if (this.state === 'inactive') {
+            return 'none';
+        }
+    }
+    /** controls animation */
+    state = 'inactive';
+    timeout;
+    intervalId;
+    hideTime;
+    sub;
+    sub1;
+    sub2;
+    sub3;
+    constructor(toastrService, toastPackage, appRef) {
+        this.toastrService = toastrService;
+        this.toastPackage = toastPackage;
+        this.appRef = appRef;
+        this.message = toastPackage.message;
+        this.title = toastPackage.title;
+        this.options = toastPackage.config;
+        this.originalTimeout = toastPackage.config.timeOut;
+        this.toastClasses = `${toastPackage.toastType} ${toastPackage.config.toastClass}`;
+        this.sub = toastPackage.toastRef.afterActivate().subscribe(() => {
+            this.activateToast();
+        });
+        this.sub1 = toastPackage.toastRef.manualClosed().subscribe(() => {
+            this.remove();
+        });
+        this.sub2 = toastPackage.toastRef.timeoutReset().subscribe(() => {
+            this.resetTimeout();
+        });
+        this.sub3 = toastPackage.toastRef.countDuplicate().subscribe(count => {
+            this.duplicatesCount = count;
+        });
+    }
+    ngOnDestroy() {
+        this.sub.unsubscribe();
+        this.sub1.unsubscribe();
+        this.sub2.unsubscribe();
+        this.sub3.unsubscribe();
+        clearInterval(this.intervalId);
+        clearTimeout(this.timeout);
+    }
+    /**
+     * activates toast and sets timeout
+     */
+    activateToast() {
+        this.state = 'active';
+        if (!(this.options.disableTimeOut === true || this.options.disableTimeOut === 'timeOut') && this.options.timeOut) {
+            this.timeout = setTimeout(() => {
+                this.remove();
+            }, this.options.timeOut);
+            this.hideTime = new Date().getTime() + this.options.timeOut;
+            if (this.options.progressBar) {
+                this.intervalId = setInterval(() => this.updateProgress(), 10);
+            }
+        }
+        if (this.options.onActivateTick) {
+            this.appRef.tick();
+        }
+    }
+    /**
+     * updates progress bar width
+     */
+    updateProgress() {
+        if (this.width === 0 || this.width === 100 || !this.options.timeOut) {
+            return;
+        }
+        const now = new Date().getTime();
+        const remaining = this.hideTime - now;
+        this.width = (remaining / this.options.timeOut) * 100;
+        if (this.options.progressAnimation === 'increasing') {
+            this.width = 100 - this.width;
+        }
+        if (this.width <= 0) {
+            this.width = 0;
+        }
+        if (this.width >= 100) {
+            this.width = 100;
+        }
+    }
+    resetTimeout() {
+        clearTimeout(this.timeout);
+        clearInterval(this.intervalId);
+        this.state = 'active';
+        this.options.timeOut = this.originalTimeout;
+        this.timeout = setTimeout(() => this.remove(), this.originalTimeout);
+        this.hideTime = new Date().getTime() + (this.originalTimeout || 0);
+        this.width = -1;
+        if (this.options.progressBar) {
+            this.intervalId = setInterval(() => this.updateProgress(), 10);
+        }
+    }
+    /**
+     * tells toastrService to remove this toast after animation time
+     */
+    remove() {
+        if (this.state === 'removed') {
+            return;
+        }
+        clearTimeout(this.timeout);
+        this.state = 'removed';
+        this.timeout = setTimeout(() => this.toastrService.remove(this.toastPackage.toastId));
+    }
+    tapToast() {
+        if (this.state === 'removed') {
+            return;
+        }
+        this.toastPackage.triggerTap();
+        if (this.options.tapToDismiss) {
+            this.remove();
+        }
+    }
+    stickAround() {
+        if (this.state === 'removed') {
+            return;
+        }
+        clearTimeout(this.timeout);
+        this.options.timeOut = 0;
+        this.hideTime = 0;
+        // disable progressBar
+        clearInterval(this.intervalId);
+        this.width = 0;
+    }
+    delayedHideToast() {
+        if ((this.options.disableTimeOut === true || this.options.disableTimeOut === 'extendedTimeOut') ||
+            this.options.extendedTimeOut === 0 ||
+            this.state === 'removed') {
+            return;
+        }
+        this.timeout = setTimeout(() => this.remove(), this.options.extendedTimeOut);
+        this.options.timeOut = this.options.extendedTimeOut;
+        this.hideTime = new Date().getTime() + (this.options.timeOut || 0);
+        this.width = -1;
+        if (this.options.progressBar) {
+            this.intervalId = setInterval(() => this.updateProgress(), 10);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimation, deps: [{ token: i1.ToastrService }, { token: i2.ToastPackage }, { token: i0.ApplicationRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.1", type: ToastNoAnimation, isStandalone: true, selector: "[toast-component]", host: { listeners: { "click": "tapToast()", "mouseenter": "stickAround()", "mouseleave": "delayedHideToast()" }, properties: { "class": "this.toastClasses", "style.display": "this.displayStyle" } }, ngImport: i0, template: `
+  <button *ngIf="options.closeButton" (click)="remove()" type="button" class="toast-close-button" aria-label="Close">
+    <span aria-hidden="true">&times;</span>
+  </button>
+  <div *ngIf="title" [class]="options.titleClass" [attr.aria-label]="title">
+    {{ title }} <ng-container *ngIf="duplicatesCount">[{{ duplicatesCount + 1 }}]</ng-container>
+  </div>
+  <div *ngIf="message && options.enableHtml" role="alert"
+    [class]="options.messageClass" [innerHTML]="message">
+  </div>
+  <div *ngIf="message && !options.enableHtml" role="alert"
+    [class]="options.messageClass" [attr.aria-label]="message">
+    {{ message }}
+  </div>
+  <div *ngIf="options.progressBar">
+    <div class="toast-progress" [style.width]="width + '%'"></div>
+  </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+}
+export { ToastNoAnimation };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimation, decorators: [{
+            type: Component,
+            args: [{
+                    selector: '[toast-component]',
+                    template: `
+  <button *ngIf="options.closeButton" (click)="remove()" type="button" class="toast-close-button" aria-label="Close">
+    <span aria-hidden="true">&times;</span>
+  </button>
+  <div *ngIf="title" [class]="options.titleClass" [attr.aria-label]="title">
+    {{ title }} <ng-container *ngIf="duplicatesCount">[{{ duplicatesCount + 1 }}]</ng-container>
+  </div>
+  <div *ngIf="message && options.enableHtml" role="alert"
+    [class]="options.messageClass" [innerHTML]="message">
+  </div>
+  <div *ngIf="message && !options.enableHtml" role="alert"
+    [class]="options.messageClass" [attr.aria-label]="message">
+    {{ message }}
+  </div>
+  <div *ngIf="options.progressBar">
+    <div class="toast-progress" [style.width]="width + '%'"></div>
+  </div>
+  `,
+                    standalone: true,
+                    imports: [NgIf]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ToastrService }, { type: i2.ToastPackage }, { type: i0.ApplicationRef }]; }, propDecorators: { toastClasses: [{
+                type: HostBinding,
+                args: ['class']
+            }], displayStyle: [{
+                type: HostBinding,
+                args: ['style.display']
+            }], tapToast: [{
+                type: HostListener,
+                args: ['click']
+            }], stickAround: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], delayedHideToast: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+export const DefaultNoAnimationsGlobalConfig = {
+    ...DefaultNoComponentGlobalConfig,
+    toastComponent: ToastNoAnimation,
+};
+class ToastNoAnimationModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: ToastNoAnimationModule,
+            providers: [
+                {
+                    provide: TOAST_CONFIG,
+                    useValue: {
+                        default: DefaultNoAnimationsGlobalConfig,
+                        config,
+                    },
+                },
+            ],
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimationModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimationModule, imports: [ToastNoAnimation], exports: [ToastNoAnimation] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimationModule });
+}
+export { ToastNoAnimationModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.1", ngImport: i0, type: ToastNoAnimationModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [ToastNoAnimation],
+                    exports: [ToastNoAnimation],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"toast-noanimation.component.js","sourceRoot":"","sources":["../../../src/lib/toastr/toast-noanimation.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgIf } from '@angular/common';\nimport { ModuleWithProviders } from '@angular/core';\nimport {\n  ApplicationRef,\n  Component,\n  HostBinding,\n  HostListener,\n  NgModule,\n  OnDestroy,\n} from '@angular/core';\n\nimport { Subscription } from 'rxjs';\n\nimport {\n  DefaultNoComponentGlobalConfig,\n  GlobalConfig,\n  IndividualConfig,\n  ToastPackage,\n  TOAST_CONFIG,\n} from './toastr-config';\nimport { ToastrService } from './toastr.service';\n\n@Component({\n  selector: '[toast-component]',\n  template: `\n  <button *ngIf=\"options.closeButton\" (click)=\"remove()\" type=\"button\" class=\"toast-close-button\" aria-label=\"Close\">\n    <span aria-hidden=\"true\">&times;</span>\n  </button>\n  <div *ngIf=\"title\" [class]=\"options.titleClass\" [attr.aria-label]=\"title\">\n    {{ title }} <ng-container *ngIf=\"duplicatesCount\">[{{ duplicatesCount + 1 }}]</ng-container>\n  </div>\n  <div *ngIf=\"message && options.enableHtml\" role=\"alert\"\n    [class]=\"options.messageClass\" [innerHTML]=\"message\">\n  </div>\n  <div *ngIf=\"message && !options.enableHtml\" role=\"alert\"\n    [class]=\"options.messageClass\" [attr.aria-label]=\"message\">\n    {{ message }}\n  </div>\n  <div *ngIf=\"options.progressBar\">\n    <div class=\"toast-progress\" [style.width]=\"width + '%'\"></div>\n  </div>\n  `,\n  standalone: true,\n  imports: [NgIf]\n})\nexport class ToastNoAnimation implements OnDestroy {\n  message?: string | null;\n  title?: string;\n  options: IndividualConfig;\n  duplicatesCount!: number;\n  originalTimeout: number;\n  /** width of progress bar */\n  width = -1;\n  /** a combination of toast type and options.toastClass */\n  @HostBinding('class') toastClasses = '';\n\n  /** hides component when waiting to be displayed */\n  @HostBinding('style.display')\n  get displayStyle() {\n    if (this.state === 'inactive') {\n      return 'none';\n    }\n  }\n\n  /** controls animation */\n  state = 'inactive';\n  private timeout: any;\n  private intervalId: any;\n  private hideTime!: number;\n  private sub: Subscription;\n  private sub1: Subscription;\n  private sub2: Subscription;\n  private sub3: Subscription;\n\n  constructor(\n    protected toastrService: ToastrService,\n    public toastPackage: ToastPackage,\n    protected appRef: ApplicationRef,\n  ) {\n    this.message = toastPackage.message;\n    this.title = toastPackage.title;\n    this.options = toastPackage.config;\n    this.originalTimeout = toastPackage.config.timeOut;\n    this.toastClasses = `${toastPackage.toastType} ${\n      toastPackage.config.toastClass\n    }`;\n    this.sub = toastPackage.toastRef.afterActivate().subscribe(() => {\n      this.activateToast();\n    });\n    this.sub1 = toastPackage.toastRef.manualClosed().subscribe(() => {\n      this.remove();\n    });\n    this.sub2 = toastPackage.toastRef.timeoutReset().subscribe(() => {\n      this.resetTimeout();\n    });\n    this.sub3 = toastPackage.toastRef.countDuplicate().subscribe(count => {\n      this.duplicatesCount = count;\n    });\n  }\n  ngOnDestroy() {\n    this.sub.unsubscribe();\n    this.sub1.unsubscribe();\n    this.sub2.unsubscribe();\n    this.sub3.unsubscribe();\n    clearInterval(this.intervalId);\n    clearTimeout(this.timeout);\n  }\n  /**\n   * activates toast and sets timeout\n   */\n  activateToast() {\n    this.state = 'active';\n    if (!(this.options.disableTimeOut === true || this.options.disableTimeOut === 'timeOut') && this.options.timeOut) {\n      this.timeout = setTimeout(() => {\n        this.remove();\n      }, this.options.timeOut);\n      this.hideTime = new Date().getTime() + this.options.timeOut;\n      if (this.options.progressBar) {\n        this.intervalId = setInterval(() => this.updateProgress(), 10);\n      }\n    }\n    if (this.options.onActivateTick) {\n      this.appRef.tick();\n    }\n  }\n  /**\n   * updates progress bar width\n   */\n  updateProgress() {\n    if (this.width === 0 || this.width === 100 || !this.options.timeOut) {\n      return;\n    }\n    const now = new Date().getTime();\n    const remaining = this.hideTime - now;\n    this.width = (remaining / this.options.timeOut) * 100;\n    if (this.options.progressAnimation === 'increasing') {\n      this.width = 100 - this.width;\n    }\n    if (this.width <= 0) {\n      this.width = 0;\n    }\n    if (this.width >= 100) {\n      this.width = 100;\n    }\n  }\n\n  resetTimeout() {\n    clearTimeout(this.timeout);\n    clearInterval(this.intervalId);\n    this.state = 'active';\n\n    this.options.timeOut = this.originalTimeout;\n    this.timeout = setTimeout(() => this.remove(), this.originalTimeout);\n    this.hideTime = new Date().getTime() + (this.originalTimeout || 0);\n    this.width = -1;\n    if (this.options.progressBar) {\n      this.intervalId = setInterval(() => this.updateProgress(), 10);\n    }\n  }\n\n  /**\n   * tells toastrService to remove this toast after animation time\n   */\n  remove() {\n    if (this.state === 'removed') {\n      return;\n    }\n    clearTimeout(this.timeout);\n    this.state = 'removed';\n    this.timeout = setTimeout(() =>\n      this.toastrService.remove(this.toastPackage.toastId),\n    );\n  }\n  @HostListener('click')\n  tapToast() {\n    if (this.state === 'removed') {\n      return;\n    }\n    this.toastPackage.triggerTap();\n    if (this.options.tapToDismiss) {\n      this.remove();\n    }\n  }\n  @HostListener('mouseenter')\n  stickAround() {\n    if (this.state === 'removed') {\n      return;\n    }\n    clearTimeout(this.timeout);\n    this.options.timeOut = 0;\n    this.hideTime = 0;\n\n    // disable progressBar\n    clearInterval(this.intervalId);\n    this.width = 0;\n  }\n  @HostListener('mouseleave')\n  delayedHideToast() {\n    if (\n      (this.options.disableTimeOut === true || this.options.disableTimeOut === 'extendedTimeOut') ||\n      this.options.extendedTimeOut === 0 ||\n      this.state === 'removed'\n    ) {\n      return;\n    }\n    this.timeout = setTimeout(\n      () => this.remove(),\n      this.options.extendedTimeOut,\n    );\n    this.options.timeOut = this.options.extendedTimeOut;\n    this.hideTime = new Date().getTime() + (this.options.timeOut || 0);\n    this.width = -1;\n    if (this.options.progressBar) {\n      this.intervalId = setInterval(() => this.updateProgress(), 10);\n    }\n  }\n}\n\nexport const DefaultNoAnimationsGlobalConfig: GlobalConfig = {\n  ...DefaultNoComponentGlobalConfig,\n  toastComponent: ToastNoAnimation,\n};\n\n@NgModule({\n  imports: [ToastNoAnimation],\n  exports: [ToastNoAnimation],\n})\nexport class ToastNoAnimationModule {\n  static forRoot(config: Partial<GlobalConfig> = {}): ModuleWithProviders<ToastNoAnimationModule> {\n    return {\n      ngModule: ToastNoAnimationModule,\n      providers: [\n        {\n          provide: TOAST_CONFIG,\n          useValue: {\n            default: DefaultNoAnimationsGlobalConfig,\n            config,\n          },\n        },\n      ],\n    };\n  }\n}\n"]}

package/esm2022/toastr/toast-ref.mjs

@@ -0,0 +1,75 @@
+import { Subject } from 'rxjs';
+/**
+ * Reference to a toast opened via the Toastr service.
+ */
+export class ToastRef {
+    _overlayRef;
+    /** The instance of component opened into the toast. */
+    componentInstance;
+    /** Count of duplicates of this toast */
+    duplicatesCount = 0;
+    /** Subject for notifying the user that the toast has finished closing. */
+    _afterClosed = new Subject();
+    /** triggered when toast is activated */
+    _activate = new Subject();
+    /** notifies the toast that it should close before the timeout */
+    _manualClose = new Subject();
+    /** notifies the toast that it should reset the timeouts */
+    _resetTimeout = new Subject();
+    /** notifies the toast that it should count a duplicate toast */
+    _countDuplicate = new Subject();
+    constructor(_overlayRef) {
+        this._overlayRef = _overlayRef;
+    }
+    manualClose() {
+        this._manualClose.next();
+        this._manualClose.complete();
+    }
+    manualClosed() {
+        return this._manualClose.asObservable();
+    }
+    timeoutReset() {
+        return this._resetTimeout.asObservable();
+    }
+    countDuplicate() {
+        return this._countDuplicate.asObservable();
+    }
+    /**
+     * Close the toast.
+     */
+    close() {
+        this._overlayRef.detach();
+        this._afterClosed.next();
+        this._manualClose.next();
+        this._afterClosed.complete();
+        this._manualClose.complete();
+        this._activate.complete();
+        this._resetTimeout.complete();
+        this._countDuplicate.complete();
+    }
+    /** Gets an observable that is notified when the toast is finished closing. */
+    afterClosed() {
+        return this._afterClosed.asObservable();
+    }
+    isInactive() {
+        return this._activate.isStopped;
+    }
+    activate() {
+        this._activate.next();
+        this._activate.complete();
+    }
+    /** Gets an observable that is notified when the toast has started opening. */
+    afterActivate() {
+        return this._activate.asObservable();
+    }
+    /** Reset the toast timouts and count duplicates */
+    onDuplicate(resetTimeout, countDuplicate) {
+        if (resetTimeout) {
+            this._resetTimeout.next();
+        }
+        if (countDuplicate) {
+            this._countDuplicate.next(++this.duplicatesCount);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9hc3QtcmVmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90b2FzdHIvdG9hc3QtcmVmLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxPQUFPLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFHM0M7O0dBRUc7QUFDSCxNQUFNLE9BQU8sUUFBUTtJQWtCQztJQWpCcEIsdURBQXVEO0lBQ3ZELGlCQUFpQixDQUFLO0lBRXRCLHdDQUF3QztJQUNoQyxlQUFlLEdBQUcsQ0FBQyxDQUFDO0lBRTVCLDBFQUEwRTtJQUNsRSxZQUFZLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztJQUMzQyx3Q0FBd0M7SUFDaEMsU0FBUyxHQUFHLElBQUksT0FBTyxFQUFRLENBQUM7SUFDeEMsaUVBQWlFO0lBQ3pELFlBQVksR0FBRyxJQUFJLE9BQU8sRUFBUSxDQUFDO0lBQzNDLDJEQUEyRDtJQUNuRCxhQUFhLEdBQUcsSUFBSSxPQUFPLEVBQVEsQ0FBQztJQUM1QyxnRUFBZ0U7SUFDeEQsZUFBZSxHQUFHLElBQUksT0FBTyxFQUFVLENBQUM7SUFFaEQsWUFBb0IsV0FBdUI7UUFBdkIsZ0JBQVcsR0FBWCxXQUFXLENBQVk7SUFBRyxDQUFDO0lBRS9DLFdBQVc7UUFDVCxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDL0IsQ0FBQztJQUVELFlBQVk7UUFDVixPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDMUMsQ0FBQztJQUVELFlBQVk7UUFDVixPQUFPLElBQUksQ0FBQyxhQUFhLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDM0MsQ0FBQztJQUVELGNBQWM7UUFDWixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDN0MsQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSztRQUNILElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDMUIsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUN6QixJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxZQUFZLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDN0IsSUFBSSxDQUFDLFlBQVksQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUM3QixJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQzFCLElBQUksQ0FBQyxhQUFhLENBQUMsUUFBUSxFQUFFLENBQUM7UUFDOUIsSUFBSSxDQUFDLGVBQWUsQ0FBQyxRQUFRLEVBQUUsQ0FBQztJQUNsQyxDQUFDO0lBRUQsOEVBQThFO0lBQzlFLFdBQVc7UUFDVCxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDMUMsQ0FBQztJQUVELFVBQVU7UUFDUixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDO0lBQ2xDLENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUN0QixJQUFJLENBQUMsU0FBUyxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCw4RUFBOEU7SUFDOUUsYUFBYTtRQUNYLE9BQU8sSUFBSSxDQUFDLFNBQVMsQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUN2QyxDQUFDO0lBRUQsbURBQW1EO0lBQ25ELFdBQVcsQ0FBQyxZQUFxQixFQUFFLGNBQXVCO1FBQ3hELElBQUksWUFBWSxFQUFFO1lBQ2hCLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLENBQUM7U0FDM0I7UUFDRCxJQUFJLGNBQWMsRUFBRTtZQUNsQixJQUFJLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxFQUFFLElBQUksQ0FBQyxlQUFlLENBQUMsQ0FBQztTQUNuRDtJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUsIFN1YmplY3QgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IE92ZXJsYXlSZWYgfSBmcm9tICcuLi9vdmVybGF5L292ZXJsYXktcmVmJztcblxuLyoqXG4gKiBSZWZlcmVuY2UgdG8gYSB0b2FzdCBvcGVuZWQgdmlhIHRoZSBUb2FzdHIgc2VydmljZS5cbiAqL1xuZXhwb3J0IGNsYXNzIFRvYXN0UmVmPFQ+IHtcbiAgLyoqIFRoZSBpbnN0YW5jZSBvZiBjb21wb25lbnQgb3BlbmVkIGludG8gdGhlIHRvYXN0LiAqL1xuICBjb21wb25lbnRJbnN0YW5jZSE6IFQ7XG5cbiAgLyoqIENvdW50IG9mIGR1cGxpY2F0ZXMgb2YgdGhpcyB0b2FzdCAqL1xuICBwcml2YXRlIGR1cGxpY2F0ZXNDb3VudCA9IDA7XG5cbiAgLyoqIFN1YmplY3QgZm9yIG5vdGlmeWluZyB0aGUgdXNlciB0aGF0IHRoZSB0b2FzdCBoYXMgZmluaXNoZWQgY2xvc2luZy4gKi9cbiAgcHJpdmF0ZSBfYWZ0ZXJDbG9zZWQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuICAvKiogdHJpZ2dlcmVkIHdoZW4gdG9hc3QgaXMgYWN0aXZhdGVkICovXG4gIHByaXZhdGUgX2FjdGl2YXRlID0gbmV3IFN1YmplY3Q8dm9pZD4oKTtcbiAgLyoqIG5vdGlmaWVzIHRoZSB0b2FzdCB0aGF0IGl0IHNob3VsZCBjbG9zZSBiZWZvcmUgdGhlIHRpbWVvdXQgKi9cbiAgcHJpdmF0ZSBfbWFudWFsQ2xvc2UgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuICAvKiogbm90aWZpZXMgdGhlIHRvYXN0IHRoYXQgaXQgc2hvdWxkIHJlc2V0IHRoZSB0aW1lb3V0cyAqL1xuICBwcml2YXRlIF9yZXNldFRpbWVvdXQgPSBuZXcgU3ViamVjdDx2b2lkPigpO1xuICAvKiogbm90aWZpZXMgdGhlIHRvYXN0IHRoYXQgaXQgc2hvdWxkIGNvdW50IGEgZHVwbGljYXRlIHRvYXN0ICovXG4gIHByaXZhdGUgX2NvdW50RHVwbGljYXRlID0gbmV3IFN1YmplY3Q8bnVtYmVyPigpO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX292ZXJsYXlSZWY6IE92ZXJsYXlSZWYpIHt9XG5cbiAgbWFudWFsQ2xvc2UoKSB7XG4gICAgdGhpcy5fbWFudWFsQ2xvc2UubmV4dCgpO1xuICAgIHRoaXMuX21hbnVhbENsb3NlLmNvbXBsZXRlKCk7XG4gIH1cblxuICBtYW51YWxDbG9zZWQoKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5fbWFudWFsQ2xvc2UuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICB0aW1lb3V0UmVzZXQoKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5fcmVzZXRUaW1lb3V0LmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgY291bnREdXBsaWNhdGUoKTogT2JzZXJ2YWJsZTxudW1iZXI+IHtcbiAgICByZXR1cm4gdGhpcy5fY291bnREdXBsaWNhdGUuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICAvKipcbiAgICogQ2xvc2UgdGhlIHRvYXN0LlxuICAgKi9cbiAgY2xvc2UoKTogdm9pZCB7XG4gICAgdGhpcy5fb3ZlcmxheVJlZi5kZXRhY2goKTtcbiAgICB0aGlzLl9hZnRlckNsb3NlZC5uZXh0KCk7XG4gICAgdGhpcy5fbWFudWFsQ2xvc2UubmV4dCgpO1xuICAgIHRoaXMuX2FmdGVyQ2xvc2VkLmNvbXBsZXRlKCk7XG4gICAgdGhpcy5fbWFudWFsQ2xvc2UuY29tcGxldGUoKTtcbiAgICB0aGlzLl9hY3RpdmF0ZS5jb21wbGV0ZSgpO1xuICAgIHRoaXMuX3Jlc2V0VGltZW91dC5jb21wbGV0ZSgpO1xuICAgIHRoaXMuX2NvdW50RHVwbGljYXRlLmNvbXBsZXRlKCk7XG4gIH1cblxuICAvKiogR2V0cyBhbiBvYnNlcnZhYmxlIHRoYXQgaXMgbm90aWZpZWQgd2hlbiB0aGUgdG9hc3QgaXMgZmluaXNoZWQgY2xvc2luZy4gKi9cbiAgYWZ0ZXJDbG9zZWQoKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICByZXR1cm4gdGhpcy5fYWZ0ZXJDbG9zZWQuYXNPYnNlcnZhYmxlKCk7XG4gIH1cblxuICBpc0luYWN0aXZlKCkge1xuICAgIHJldHVybiB0aGlzLl9hY3RpdmF0ZS5pc1N0b3BwZWQ7XG4gIH1cblxuICBhY3RpdmF0ZSgpIHtcbiAgICB0aGlzLl9hY3RpdmF0ZS5uZXh0KCk7XG4gICAgdGhpcy5fYWN0aXZhdGUuY29tcGxldGUoKTtcbiAgfVxuXG4gIC8qKiBHZXRzIGFuIG9ic2VydmFibGUgdGhhdCBpcyBub3RpZmllZCB3aGVuIHRoZSB0b2FzdCBoYXMgc3RhcnRlZCBvcGVuaW5nLiAqL1xuICBhZnRlckFjdGl2YXRlKCk6IE9ic2VydmFibGU8YW55PiB7XG4gICAgcmV0dXJuIHRoaXMuX2FjdGl2YXRlLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgLyoqIFJlc2V0IHRoZSB0b2FzdCB0aW1vdXRzIGFuZCBjb3VudCBkdXBsaWNhdGVzICovXG4gIG9uRHVwbGljYXRlKHJlc2V0VGltZW91dDogYm9vbGVhbiwgY291bnREdXBsaWNhdGU6IGJvb2xlYW4pIHtcbiAgICBpZiAocmVzZXRUaW1lb3V0KSB7XG4gICAgICB0aGlzLl9yZXNldFRpbWVvdXQubmV4dCgpO1xuICAgIH1cbiAgICBpZiAoY291bnREdXBsaWNhdGUpIHtcbiAgICAgIHRoaXMuX2NvdW50RHVwbGljYXRlLm5leHQoKyt0aGlzLmR1cGxpY2F0ZXNDb3VudCk7XG4gICAgfVxuICB9XG59XG4iXX0=