atr-components 2.0.204 → 2.0.205

package/esm2020/core/interceptor/base.interceptor.mjs

@@ -0,0 +1,165 @@
+import { Injectable } from '@angular/core';
+import { HttpErrorResponse, HttpResponseBase, HttpResponse } from '@angular/common/http';
+import { Observable, of, throwError } from 'rxjs';
+import { mergeMap, catchError } from 'rxjs/operators';
+import { Router } from '@angular/router';
+import { NzNotificationService } from 'ng-zorro-antd/notification';
+import { NzMessageService } from 'ng-zorro-antd/message';
+import { LocalStorageUtil } from "../utils/localstorage.util";
+import { AtrReuseStrategy } from "../routereuse/atr-reuse-strategy";
+import { MenuService } from "../services/menu.service";
+import { atr_static_datas } from "../base/atr-common";
+import * as i0 from "@angular/core";
+const CODEMESSAGE = {
+    200: '服务器成功返回请求的数据。',
+    201: '新建或修改数据成功。',
+    202: '一个请求已经进入后台排队（异步任务）。',
+    204: '删除数据成功。',
+    400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',
+    401: '用户没有权限（令牌、用户名、密码错误）。',
+    403: '用户得到授权，但是访问是被禁止的。',
+    404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',
+    406: '请求的格式不可得。',
+    410: '请求的资源被永久删除，且不会再得到的。',
+    422: '当创建一个对象时，发生一个验证错误。',
+    500: '服务器发生错误，请检查服务器。',
+    502: '网关错误。',
+    503: '服务不可用，服务器暂时过载或维护。',
+    504: '网关超时。',
+};
+export class BaseInterceptor {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    get notification() {
+        return this.injector.get(NzNotificationService);
+    }
+    get message() {
+        return this.injector.get(NzMessageService);
+    }
+    get menuService() {
+        return this.injector.get(MenuService);
+    }
+    goTo(url, isClearCache) {
+        // console.log("需要跳转到页面：")
+        // console.log(url);
+        setTimeout(() => this.injector.get(Router).navigateByUrl(url));
+        if (isClearCache) {
+            setTimeout(() => AtrReuseStrategy.deleteAll(), 50);
+        }
+    }
+    checkStatus(ev) {
+        if ((ev.status >= 200 && ev.status < 300) || ev.status === 401) {
+            return;
+        }
+        // console.log(ev.status);
+        // const errortext = CODEMESSAGE[ev.status] || ev.statusText;
+        this.message.error('网络错误,请稍后重试：' + ev.status);
+    }
+    handleData(ev, noTip = false) {
+        this.checkStatus(ev);
+        // 业务处理：一些通用操作
+        switch (ev.status) {
+            case 200:
+                // TODO status
+                // 业务层级错误处理，以下是假定restful有一套统一输出格式（指不管成功与否都有相应的数据格式）情况下进行处理
+                // 例如响应内容：
+                //  错误内容：{ status: 1, msg: '非法参数' }
+                //  正确内容：{ status: 0, response: {  } }
+                // 则以下代码片断可直接适用
+                if (ev instanceof HttpResponse) {
+                    const body = ev.body;
+                    if (body && body.status === 401) {
+                        if (!noTip) {
+                            this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
+                                nzKey: 'outTime'
+                            });
+                        }
+                        // TODO 清空 token 信息
+                        LocalStorageUtil.clearUs();
+                        this.menuService.clear();
+                        this.goTo('/p/login', true);
+                    }
+                    else if (body && body.status === 1024) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(body.message);
+                        }
+                    }
+                    else if (body && body.status === 1025) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(`参数为空。`);
+                        }
+                    }
+                    else if (body && body.status === 503) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.error(body.message);
+                        }
+                    }
+                    else if (body && body.status === 204) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.success(body.message);
+                        }
+                    }
+                    else if (body && body.status === 201) {
+                        // 或者依然保持完整的格式
+                        if (!noTip) {
+                            this.message.success(body.message);
+                        }
+                    }
+                    else {
+                        return of(ev);
+                    }
+                }
+                break;
+            case 401:
+                this.notification.error(`未登录或登录已过期，请重新登录。`, ``, {
+                    nzKey: 'outTime'
+                });
+                // TODO 清空 token 信息
+                // this.goTo('/p/login',false);
+                break;
+            case 403:
+            case 404:
+            case 500:
+                this.goTo(`/exception/${ev.status}`, false);
+                break;
+            default:
+                if (ev instanceof HttpErrorResponse) {
+                    // console.warn('未可知错误，大部分是由于后端不支持CORS或无效配置引起', ev);
+                    return throwError(ev);
+                }
+                break;
+        }
+        return of(ev);
+    }
+    intercept(req, next) {
+        if (!atr_static_datas.SERVER_URL) {
+            alert('请配置ip atr_static_datas.SERVER_URL');
+            return new Observable();
+        }
+        // 统一加上服务端前缀
+        let url = req.url;
+        if (!url.startsWith('https://') && !url.startsWith('http://')) {
+            url = atr_static_datas.SERVER_URL + url;
+            req = req.clone({ url });
+        }
+        let noTip = req.headers.get("noTip");
+        return next.handle(req).pipe(mergeMap((event) => {
+            // 允许统一对请求错误处理
+            if (event instanceof HttpResponseBase)
+                return this.handleData(event, noTip == "1");
+            // 若一切都正常，则后续操作
+            return of(event);
+        }), catchError((err) => this.handleData(err, noTip == "1")));
+    }
+}
+BaseInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: BaseInterceptor, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+BaseInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: BaseInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: BaseInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base.interceptor.js","sourceRoot":"","sources":["../../../../../projects/components/src/core/interceptor/base.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Injector } from '@angular/core';\r\nimport { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse, HttpResponseBase, HttpResponse, HttpHeaders } from '@angular/common/http';\r\nimport { Observable, of ,throwError  } from 'rxjs';\r\nimport { mergeMap, catchError } from 'rxjs/operators';\r\nimport { Router } from '@angular/router';\r\nimport { NzNotificationService } from 'ng-zorro-antd/notification';\r\nimport {NzMessageService} from 'ng-zorro-antd/message';\r\nimport {LocalStorageUtil} from \"../utils/localstorage.util\";\r\nimport {environment} from \"ng-zorro-antd/core/environments\";\r\nimport {AtrReuseStrategy} from \"../routereuse/atr-reuse-strategy\";\r\nimport {MenuService} from \"../services/menu.service\";\r\nimport {atr_static_datas} from \"../base/atr-common\";\r\n\r\nconst CODEMESSAGE = {\r\n    200: '服务器成功返回请求的数据。',\r\n    201: '新建或修改数据成功。',\r\n    202: '一个请求已经进入后台排队（异步任务）。',\r\n    204: '删除数据成功。',\r\n    400: '发出的请求有错误，服务器没有进行新建或修改数据的操作。',\r\n    401: '用户没有权限（令牌、用户名、密码错误）。',\r\n    403: '用户得到授权，但是访问是被禁止的。',\r\n    404: '发出的请求针对的是不存在的记录，服务器没有进行操作。',\r\n    406: '请求的格式不可得。',\r\n    410: '请求的资源被永久删除，且不会再得到的。',\r\n    422: '当创建一个对象时，发生一个验证错误。',\r\n    500: '服务器发生错误，请检查服务器。',\r\n    502: '网关错误。',\r\n    503: '服务不可用，服务器暂时过载或维护。',\r\n    504: '网关超时。',\r\n};\r\n\r\n@Injectable()\r\nexport class BaseInterceptor implements HttpInterceptor{\r\n    constructor(private injector: Injector) {}\r\n    private get notification(): NzNotificationService {\r\n        return this.injector.get(NzNotificationService);\r\n    }\r\n    private get message(): NzMessageService {\r\n        return this.injector.get(NzMessageService);\r\n    }\r\n    private get menuService(): MenuService{\r\n        return this.injector.get(MenuService)\r\n    }\r\n\r\n    private goTo(url: string,isClearCache:boolean) {\r\n      // console.log(\"需要跳转到页面：\")\r\n      // console.log(url);\r\n      setTimeout(() => this.injector.get(Router).navigateByUrl(url));\r\n      if(isClearCache){\r\n        setTimeout(()=>  AtrReuseStrategy.deleteAll(),50);\r\n      }\r\n    }\r\n\r\n    private checkStatus(ev: HttpResponseBase) {\r\n        if ((ev.status >= 200 && ev.status < 300) || ev.status === 401) {\r\n          return;\r\n        }\r\n        // console.log(ev.status);\r\n        // const errortext = CODEMESSAGE[ev.status] || ev.statusText;\r\n        this.message.error('网络错误,请稍后重试：' + ev.status);\r\n    }\r\n    private handleData(ev: HttpResponseBase,noTip = false): Observable<any> {\r\n        this.checkStatus(ev);\r\n        // 业务处理：一些通用操作\r\n        switch (ev.status) {\r\n          case 200:\r\n            // TODO status\r\n            // 业务层级错误处理，以下是假定restful有一套统一输出格式（指不管成功与否都有相应的数据格式）情况下进行处理\r\n            // 例如响应内容：\r\n            //  错误内容：{ status: 1, msg: '非法参数' }\r\n            //  正确内容：{ status: 0, response: {  } }\r\n            // 则以下代码片断可直接适用\r\n            if (ev instanceof HttpResponse) {\r\n                const body: any = ev.body;\r\n                if (body && body.status === 401 ) {\r\n                  if(!noTip){\r\n                    this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n                      nzKey: 'outTime'\r\n                    });\r\n                  }\r\n                  // TODO 清空 token 信息\r\n                  LocalStorageUtil.clearUs()\r\n                  this.menuService.clear();\r\n                  this.goTo('/p/login',true);\r\n                } else if(body && body.status === 1024){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                } else if(body && body.status === 1025){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(`参数为空。`);\r\n                  }\r\n                } else if(body && body.status === 503){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.error(body.message);\r\n                  }\r\n                }else if(body && body.status === 204){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\r\n                }else if(body && body.status === 201){\r\n                  // 或者依然保持完整的格式\r\n                  if(!noTip) {\r\n                    this.message.success(body.message);\r\n                  }\r\n                }else{\r\n                  return of(ev);\r\n                }\r\n            }\r\n            break;\r\n          case 401:\r\n            this.notification.error(`未登录或登录已过期，请重新登录。`, ``,{\r\n              nzKey: 'outTime'\r\n            });\r\n            // TODO 清空 token 信息\r\n\r\n            // this.goTo('/p/login',false);\r\n            break;\r\n          case 403:\r\n          case 404:\r\n          case 500:\r\n            this.goTo(`/exception/${ev.status}`,false);\r\n            break;\r\n          default:\r\n            if (ev instanceof HttpErrorResponse) {\r\n              // console.warn('未可知错误，大部分是由于后端不支持CORS或无效配置引起', ev);\r\n              return throwError(ev);\r\n            }\r\n            break;\r\n        }\r\n        return of(ev);\r\n      }\r\n    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {\r\n      if(!atr_static_datas.SERVER_URL){\r\n        alert('请配置ip atr_static_datas.SERVER_URL')\r\n        return new Observable();\r\n      }\r\n        // 统一加上服务端前缀\r\n        let url = req.url;\r\n        if (!url.startsWith('https://') && !url.startsWith('http://')) {\r\n          url = atr_static_datas.SERVER_URL + url;\r\n          req = req.clone({ url });\r\n        }\r\n      let noTip = req.headers.get(\"noTip\");\r\n        return next.handle(req).pipe(\r\n          mergeMap((event: any) => {\r\n            // 允许统一对请求错误处理\r\n            if (event instanceof HttpResponseBase) return this.handleData(event,noTip == \"1\");\r\n            // 若一切都正常，则后续操作\r\n            return of(event);\r\n          }),\r\n          catchError((err: HttpErrorResponse) => this.handleData(err,noTip == \"1\")),\r\n        );\r\n      }\r\n}\r\n"]}

package/esm2020/core/ngz-module/cus-zorro-antd.module.mjs

@@ -0,0 +1,292 @@
+import { NgModule } from '@angular/core';
+import { NzAffixModule } from 'ng-zorro-antd/affix';
+import { NzAlertModule } from 'ng-zorro-antd/alert';
+import { NzAnchorModule } from 'ng-zorro-antd/anchor';
+import { NzAutocompleteModule } from 'ng-zorro-antd/auto-complete';
+import { NzAvatarModule } from 'ng-zorro-antd/avatar';
+import { NzBackTopModule } from 'ng-zorro-antd/back-top';
+import { NzBadgeModule } from 'ng-zorro-antd/badge';
+import { NzBreadCrumbModule } from 'ng-zorro-antd/breadcrumb';
+import { NzButtonModule } from 'ng-zorro-antd/button';
+import { NzCalendarModule } from 'ng-zorro-antd/calendar';
+import { NzCardModule } from 'ng-zorro-antd/card';
+import { NzCarouselModule } from 'ng-zorro-antd/carousel';
+import { NzCascaderModule } from 'ng-zorro-antd/cascader';
+import { NzCheckboxModule } from 'ng-zorro-antd/checkbox';
+import { NzCollapseModule } from 'ng-zorro-antd/collapse';
+import { NzCommentModule } from 'ng-zorro-antd/comment';
+import { NzNoAnimationModule } from 'ng-zorro-antd/core/no-animation';
+import { NzTransButtonModule } from 'ng-zorro-antd/core/trans-button';
+import { NzWaveModule } from 'ng-zorro-antd/core/wave';
+import { NzDatePickerModule } from 'ng-zorro-antd/date-picker';
+import { NzDescriptionsModule } from 'ng-zorro-antd/descriptions';
+import { NzDividerModule } from 'ng-zorro-antd/divider';
+import { NzDrawerModule } from 'ng-zorro-antd/drawer';
+import { NzDropDownModule } from 'ng-zorro-antd/dropdown';
+import { NzEmptyModule } from 'ng-zorro-antd/empty';
+import { NzFormModule } from 'ng-zorro-antd/form';
+import { NzGridModule } from 'ng-zorro-antd/grid';
+import { NzI18nModule } from 'ng-zorro-antd/i18n';
+import { NzIconModule } from 'ng-zorro-antd/icon';
+import { NzInputModule } from 'ng-zorro-antd/input';
+import { NzInputNumberModule } from 'ng-zorro-antd/input-number';
+import { NzLayoutModule } from 'ng-zorro-antd/layout';
+import { NzListModule } from 'ng-zorro-antd/list';
+import { NzMentionModule } from 'ng-zorro-antd/mention';
+import { NzMenuModule } from 'ng-zorro-antd/menu';
+import { NzMessageModule } from 'ng-zorro-antd/message';
+import { NzModalModule } from 'ng-zorro-antd/modal';
+import { NzNotificationModule } from 'ng-zorro-antd/notification';
+import { NzPageHeaderModule } from 'ng-zorro-antd/page-header';
+import { NzPaginationModule } from 'ng-zorro-antd/pagination';
+import { NzPopconfirmModule } from 'ng-zorro-antd/popconfirm';
+import { NzPopoverModule } from 'ng-zorro-antd/popover';
+import { NzProgressModule } from 'ng-zorro-antd/progress';
+import { NzRadioModule } from 'ng-zorro-antd/radio';
+import { NzRateModule } from 'ng-zorro-antd/rate';
+import { NzResultModule } from 'ng-zorro-antd/result';
+import { NzSelectModule } from 'ng-zorro-antd/select';
+import { NzSkeletonModule } from 'ng-zorro-antd/skeleton';
+import { NzSliderModule } from 'ng-zorro-antd/slider';
+import { NzSpinModule } from 'ng-zorro-antd/spin';
+import { NzStatisticModule } from 'ng-zorro-antd/statistic';
+import { NzStepsModule } from 'ng-zorro-antd/steps';
+import { NzSwitchModule } from 'ng-zorro-antd/switch';
+import { NzTableModule } from 'ng-zorro-antd/table';
+import { NzTabsModule } from 'ng-zorro-antd/tabs';
+import { NzTagModule } from 'ng-zorro-antd/tag';
+import { NzTimePickerModule } from 'ng-zorro-antd/time-picker';
+import { NzTimelineModule } from 'ng-zorro-antd/timeline';
+import { NzToolTipModule } from 'ng-zorro-antd/tooltip';
+import { NzTransferModule } from 'ng-zorro-antd/transfer';
+import { NzTreeModule } from 'ng-zorro-antd/tree';
+import { NzTreeSelectModule } from 'ng-zorro-antd/tree-select';
+import { NzTypographyModule } from 'ng-zorro-antd/typography';
+import { NzUploadModule } from 'ng-zorro-antd/upload';
+import { NzResizableModule } from 'ng-zorro-antd/resizable';
+import { FormsModule, ReactiveFormsModule } from "@angular/forms";
+import { CommonModule } from "@angular/common";
+import { NzSpaceModule } from 'ng-zorro-antd/space';
+import { NzImageModule } from 'ng-zorro-antd/image';
+import * as i0 from "@angular/core";
+export class CusNgZorroAntdModule {
+}
+CusNgZorroAntdModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CusNgZorroAntdModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CusNgZorroAntdModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CusNgZorroAntdModule, exports: [CommonModule,
+        NzSpaceModule,
+        NzAffixModule,
+        NzAlertModule,
+        NzAnchorModule,
+        NzAutocompleteModule,
+        NzAvatarModule,
+        NzBackTopModule,
+        NzBadgeModule,
+        NzButtonModule,
+        NzBreadCrumbModule,
+        NzCalendarModule,
+        NzCardModule,
+        NzCarouselModule,
+        NzCascaderModule,
+        NzCheckboxModule,
+        NzCollapseModule,
+        NzCommentModule,
+        NzDatePickerModule,
+        NzDescriptionsModule,
+        NzDividerModule,
+        NzDrawerModule,
+        NzDropDownModule,
+        NzEmptyModule,
+        NzFormModule,
+        NzGridModule,
+        NzI18nModule,
+        NzIconModule,
+        NzInputModule,
+        NzInputNumberModule,
+        NzLayoutModule,
+        NzListModule,
+        NzMentionModule,
+        NzMenuModule,
+        NzMessageModule,
+        NzModalModule,
+        NzNoAnimationModule,
+        NzNotificationModule,
+        NzPageHeaderModule,
+        NzPaginationModule,
+        NzPopconfirmModule,
+        NzPopoverModule,
+        NzProgressModule,
+        NzRadioModule,
+        NzRateModule,
+        NzResultModule,
+        NzSelectModule,
+        NzSkeletonModule,
+        NzSliderModule,
+        NzSpinModule,
+        NzStatisticModule,
+        NzStepsModule,
+        NzSwitchModule,
+        NzTableModule,
+        NzTabsModule,
+        NzTagModule,
+        NzTimePickerModule,
+        NzTimelineModule,
+        NzToolTipModule,
+        NzTransButtonModule,
+        NzTransferModule,
+        NzTreeModule,
+        NzTreeSelectModule,
+        NzTypographyModule,
+        NzUploadModule,
+        NzWaveModule,
+        NzResizableModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NzImageModule] });
+CusNgZorroAntdModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CusNgZorroAntdModule, imports: [CommonModule,
+        NzSpaceModule,
+        NzAffixModule,
+        NzAlertModule,
+        NzAnchorModule,
+        NzAutocompleteModule,
+        NzAvatarModule,
+        NzBackTopModule,
+        NzBadgeModule,
+        NzButtonModule,
+        NzBreadCrumbModule,
+        NzCalendarModule,
+        NzCardModule,
+        NzCarouselModule,
+        NzCascaderModule,
+        NzCheckboxModule,
+        NzCollapseModule,
+        NzCommentModule,
+        NzDatePickerModule,
+        NzDescriptionsModule,
+        NzDividerModule,
+        NzDrawerModule,
+        NzDropDownModule,
+        NzEmptyModule,
+        NzFormModule,
+        NzGridModule,
+        NzI18nModule,
+        NzIconModule,
+        NzInputModule,
+        NzInputNumberModule,
+        NzLayoutModule,
+        NzListModule,
+        NzMentionModule,
+        NzMenuModule,
+        NzMessageModule,
+        NzModalModule,
+        NzNoAnimationModule,
+        NzNotificationModule,
+        NzPageHeaderModule,
+        NzPaginationModule,
+        NzPopconfirmModule,
+        NzPopoverModule,
+        NzProgressModule,
+        NzRadioModule,
+        NzRateModule,
+        NzResultModule,
+        NzSelectModule,
+        NzSkeletonModule,
+        NzSliderModule,
+        NzSpinModule,
+        NzStatisticModule,
+        NzStepsModule,
+        NzSwitchModule,
+        NzTableModule,
+        NzTabsModule,
+        NzTagModule,
+        NzTimePickerModule,
+        NzTimelineModule,
+        NzToolTipModule,
+        NzTransButtonModule,
+        NzTransferModule,
+        NzTreeModule,
+        NzTreeSelectModule,
+        NzTypographyModule,
+        NzUploadModule,
+        NzWaveModule,
+        NzResizableModule,
+        FormsModule,
+        ReactiveFormsModule,
+        NzImageModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CusNgZorroAntdModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    exports: [
+                        CommonModule,
+                        NzSpaceModule,
+                        NzAffixModule,
+                        NzAlertModule,
+                        NzAnchorModule,
+                        NzAutocompleteModule,
+                        NzAvatarModule,
+                        NzBackTopModule,
+                        NzBadgeModule,
+                        NzButtonModule,
+                        NzBreadCrumbModule,
+                        NzCalendarModule,
+                        NzCardModule,
+                        NzCarouselModule,
+                        NzCascaderModule,
+                        NzCheckboxModule,
+                        NzCollapseModule,
+                        NzCommentModule,
+                        NzDatePickerModule,
+                        NzDescriptionsModule,
+                        NzDividerModule,
+                        NzDrawerModule,
+                        NzDropDownModule,
+                        NzEmptyModule,
+                        NzFormModule,
+                        NzGridModule,
+                        NzI18nModule,
+                        NzIconModule,
+                        NzInputModule,
+                        NzInputNumberModule,
+                        NzLayoutModule,
+                        NzListModule,
+                        NzMentionModule,
+                        NzMenuModule,
+                        NzMessageModule,
+                        NzModalModule,
+                        NzNoAnimationModule,
+                        NzNotificationModule,
+                        NzPageHeaderModule,
+                        NzPaginationModule,
+                        NzPopconfirmModule,
+                        NzPopoverModule,
+                        NzProgressModule,
+                        NzRadioModule,
+                        NzRateModule,
+                        NzResultModule,
+                        NzSelectModule,
+                        NzSkeletonModule,
+                        NzSliderModule,
+                        NzSpinModule,
+                        NzStatisticModule,
+                        NzStepsModule,
+                        NzSwitchModule,
+                        NzTableModule,
+                        NzTabsModule,
+                        NzTagModule,
+                        NzTimePickerModule,
+                        NzTimelineModule,
+                        NzToolTipModule,
+                        NzTransButtonModule,
+                        NzTransferModule,
+                        NzTreeModule,
+                        NzTreeSelectModule,
+                        NzTypographyModule,
+                        NzUploadModule,
+                        NzWaveModule,
+                        NzResizableModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        NzImageModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cus-zorro-antd.module.js","sourceRoot":"","sources":["../../../../../projects/components/src/core/ngz-module/cus-zorro-antd.module.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { NgModule } from '@angular/core';\r\n\r\nimport { NzAffixModule } from 'ng-zorro-antd/affix';\r\nimport { NzAlertModule } from 'ng-zorro-antd/alert';\r\nimport { NzAnchorModule } from 'ng-zorro-antd/anchor';\r\nimport { NzAutocompleteModule } from 'ng-zorro-antd/auto-complete';\r\nimport { NzAvatarModule } from 'ng-zorro-antd/avatar';\r\nimport { NzBackTopModule } from 'ng-zorro-antd/back-top';\r\nimport { NzBadgeModule } from 'ng-zorro-antd/badge';\r\nimport { NzBreadCrumbModule } from 'ng-zorro-antd/breadcrumb';\r\nimport { NzButtonModule } from 'ng-zorro-antd/button';\r\nimport { NzCalendarModule } from 'ng-zorro-antd/calendar';\r\nimport { NzCardModule } from 'ng-zorro-antd/card';\r\nimport { NzCarouselModule } from 'ng-zorro-antd/carousel';\r\nimport { NzCascaderModule } from 'ng-zorro-antd/cascader';\r\nimport { NzCheckboxModule } from 'ng-zorro-antd/checkbox';\r\nimport { NzCollapseModule } from 'ng-zorro-antd/collapse';\r\nimport { NzCommentModule } from 'ng-zorro-antd/comment';\r\nimport { NzNoAnimationModule } from 'ng-zorro-antd/core/no-animation';\r\nimport { NzTransButtonModule } from 'ng-zorro-antd/core/trans-button';\r\nimport { NzWaveModule } from 'ng-zorro-antd/core/wave';\r\nimport { NzDatePickerModule } from 'ng-zorro-antd/date-picker';\r\nimport { NzDescriptionsModule } from 'ng-zorro-antd/descriptions';\r\nimport { NzDividerModule } from 'ng-zorro-antd/divider';\r\nimport { NzDrawerModule } from 'ng-zorro-antd/drawer';\r\nimport { NzDropDownModule } from 'ng-zorro-antd/dropdown';\r\nimport { NzEmptyModule } from 'ng-zorro-antd/empty';\r\nimport { NzFormModule } from 'ng-zorro-antd/form';\r\nimport { NzGridModule } from 'ng-zorro-antd/grid';\r\nimport { NzI18nModule } from 'ng-zorro-antd/i18n';\r\nimport { NzIconModule } from 'ng-zorro-antd/icon';\r\nimport { NzInputModule } from 'ng-zorro-antd/input';\r\nimport { NzInputNumberModule } from 'ng-zorro-antd/input-number';\r\nimport { NzLayoutModule } from 'ng-zorro-antd/layout';\r\nimport { NzListModule } from 'ng-zorro-antd/list';\r\nimport { NzMentionModule } from 'ng-zorro-antd/mention';\r\nimport { NzMenuModule } from 'ng-zorro-antd/menu';\r\nimport { NzMessageModule } from 'ng-zorro-antd/message';\r\nimport { NzModalModule } from 'ng-zorro-antd/modal';\r\nimport { NzNotificationModule } from 'ng-zorro-antd/notification';\r\nimport { NzPageHeaderModule } from 'ng-zorro-antd/page-header';\r\nimport { NzPaginationModule } from 'ng-zorro-antd/pagination';\r\nimport { NzPopconfirmModule } from 'ng-zorro-antd/popconfirm';\r\nimport { NzPopoverModule } from 'ng-zorro-antd/popover';\r\nimport { NzProgressModule } from 'ng-zorro-antd/progress';\r\nimport { NzRadioModule } from 'ng-zorro-antd/radio';\r\nimport { NzRateModule } from 'ng-zorro-antd/rate';\r\nimport { NzResultModule } from 'ng-zorro-antd/result';\r\nimport { NzSelectModule } from 'ng-zorro-antd/select';\r\nimport { NzSkeletonModule } from 'ng-zorro-antd/skeleton';\r\nimport { NzSliderModule } from 'ng-zorro-antd/slider';\r\nimport { NzSpinModule } from 'ng-zorro-antd/spin';\r\nimport { NzStatisticModule } from 'ng-zorro-antd/statistic';\r\nimport { NzStepsModule } from 'ng-zorro-antd/steps';\r\nimport { NzSwitchModule } from 'ng-zorro-antd/switch';\r\nimport { NzTableModule } from 'ng-zorro-antd/table';\r\nimport { NzTabsModule } from 'ng-zorro-antd/tabs';\r\nimport { NzTagModule } from 'ng-zorro-antd/tag';\r\nimport { NzTimePickerModule } from 'ng-zorro-antd/time-picker';\r\nimport { NzTimelineModule } from 'ng-zorro-antd/timeline';\r\nimport { NzToolTipModule } from 'ng-zorro-antd/tooltip';\r\nimport { NzTransferModule } from 'ng-zorro-antd/transfer';\r\nimport { NzTreeModule } from 'ng-zorro-antd/tree';\r\nimport { NzTreeSelectModule } from 'ng-zorro-antd/tree-select';\r\nimport { NzTypographyModule } from 'ng-zorro-antd/typography';\r\nimport { NzUploadModule } from 'ng-zorro-antd/upload';\r\nimport { NzResizableModule } from 'ng-zorro-antd/resizable';\r\nimport {FormsModule, ReactiveFormsModule} from \"@angular/forms\";\r\nimport {CommonModule} from \"@angular/common\";\r\nimport { NzSpaceModule } from 'ng-zorro-antd/space';\r\nimport {NzImageModule} from 'ng-zorro-antd/image';\r\n\r\n@NgModule({\r\n  exports: [\r\n    CommonModule,\r\n    NzSpaceModule,\r\n    NzAffixModule,\r\n    NzAlertModule,\r\n    NzAnchorModule,\r\n    NzAutocompleteModule,\r\n    NzAvatarModule,\r\n    NzBackTopModule,\r\n    NzBadgeModule,\r\n    NzButtonModule,\r\n    NzBreadCrumbModule,\r\n    NzCalendarModule,\r\n    NzCardModule,\r\n    NzCarouselModule,\r\n    NzCascaderModule,\r\n    NzCheckboxModule,\r\n    NzCollapseModule,\r\n    NzCommentModule,\r\n    NzDatePickerModule,\r\n    NzDescriptionsModule,\r\n    NzDividerModule,\r\n    NzDrawerModule,\r\n    NzDropDownModule,\r\n    NzEmptyModule,\r\n    NzFormModule,\r\n    NzGridModule,\r\n    NzI18nModule,\r\n    NzIconModule,\r\n    NzInputModule,\r\n    NzInputNumberModule,\r\n    NzLayoutModule,\r\n    NzListModule,\r\n    NzMentionModule,\r\n    NzMenuModule,\r\n    NzMessageModule,\r\n    NzModalModule,\r\n    NzNoAnimationModule,\r\n    NzNotificationModule,\r\n    NzPageHeaderModule,\r\n    NzPaginationModule,\r\n    NzPopconfirmModule,\r\n    NzPopoverModule,\r\n    NzProgressModule,\r\n    NzRadioModule,\r\n    NzRateModule,\r\n    NzResultModule,\r\n    NzSelectModule,\r\n    NzSkeletonModule,\r\n    NzSliderModule,\r\n    NzSpinModule,\r\n    NzStatisticModule,\r\n    NzStepsModule,\r\n    NzSwitchModule,\r\n    NzTableModule,\r\n    NzTabsModule,\r\n    NzTagModule,\r\n    NzTimePickerModule,\r\n    NzTimelineModule,\r\n    NzToolTipModule,\r\n    NzTransButtonModule,\r\n    NzTransferModule,\r\n    NzTreeModule,\r\n    NzTreeSelectModule,\r\n    NzTypographyModule,\r\n    NzUploadModule,\r\n    NzWaveModule,\r\n    NzResizableModule,\r\n    FormsModule,\r\n    ReactiveFormsModule,\r\n    NzImageModule\r\n  ]\r\n})\r\nexport class CusNgZorroAntdModule {\r\n\r\n}\r\n\r\n\r\n"]}

package/esm2020/core/pipe/china-num.pipe.mjs

@@ -0,0 +1,36 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ChinaNumPipe {
+    transform(value, ...args) {
+        let changeNum = ['零', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
+        let unit = ["", "十", "百", "千", "万"];
+        if (!value)
+            return value;
+        if (typeof value === 'number') {
+            let getWan = (temp) => {
+                let strArr = temp.toString().split("").reverse();
+                let newNum = "";
+                for (var i = 0; i < strArr.length; i++) {
+                    newNum = (i == 0 && strArr[i] == 0 ? "" : (i > 0 && strArr[i] == 0 && strArr[i - 1] == 0 ? "" : changeNum[strArr[i]] + (strArr[i] == 0 ? unit[0] : unit[i]))) + newNum;
+                }
+                return newNum;
+            };
+            let overWan = Math.floor(value / 10000);
+            let noWan = value % 10000 + "";
+            if (noWan.toString().length < 4) {
+                noWan = "0" + noWan;
+            }
+            return overWan ? getWan(overWan) + "万" + getWan(noWan) + "、" : getWan(value) + "、";
+        }
+        return "";
+    }
+}
+ChinaNumPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ChinaNumPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+ChinaNumPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ChinaNumPipe, name: "chinaNum" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ChinaNumPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'chinaNum'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/pipe/count.pipe.mjs

@@ -0,0 +1,34 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CountPipe {
+    transform(value, ...args) {
+        if (!value)
+            return value;
+        if (typeof value !== 'number') {
+            throw new Error('Invalid pipe argument for WelcomePipe');
+        }
+        let leftd = Math.floor(value / (1000 * 60 * 60 * 24)), //计算天数
+        lefth = Math.floor(value / (1000 * 60 * 60) % 24), //计算小时数
+        leftm = Math.floor(value / (1000 * 60) % 60), //计算分钟数
+        lefts = Math.floor(value / 1000 % 60); //计算秒数
+        let returnStr = "";
+        if (leftd > 0) {
+            returnStr = leftd < 10 ? "0" : "" + leftd + "天";
+        }
+        // if(lefth > 0){
+        returnStr += (lefth < 10 ? "0" : "") + lefth + "小时";
+        returnStr += (leftm < 10 ? "0" : "") + leftm + "分";
+        returnStr += (lefts < 10 ? "0" : "") + lefts + "秒";
+        // }
+        return returnStr;
+    }
+}
+CountPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CountPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+CountPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CountPipe, name: "count" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: CountPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'count'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnQucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2NvcmUvcGlwZS9jb3VudC5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUtwRCxNQUFNLE9BQU8sU0FBUztJQUVwQixTQUFTLENBQUMsS0FBVSxFQUFFLEdBQUcsSUFBVztRQUNsQyxJQUFHLENBQUMsS0FBSztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQ3hCLElBQUcsT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO1lBQzVCLE1BQU0sSUFBSSxLQUFLLENBQUMsdUNBQXVDLENBQUMsQ0FBQztTQUMxRDtRQUNELElBQUksS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxHQUFDLENBQUMsSUFBSSxHQUFDLEVBQUUsR0FBQyxFQUFFLEdBQUMsRUFBRSxDQUFDLENBQUMsRUFBRyxNQUFNO1FBQ3RELEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssR0FBQyxDQUFDLElBQUksR0FBQyxFQUFFLEdBQUMsRUFBRSxDQUFDLEdBQUMsRUFBRSxDQUFDLEVBQUcsT0FBTztRQUNuRCxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEdBQUMsQ0FBQyxJQUFJLEdBQUMsRUFBRSxDQUFDLEdBQUMsRUFBRSxDQUFDLEVBQUcsT0FBTztRQUNoRCxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLEdBQUMsSUFBSSxHQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUUsTUFBTTtRQUMxQyxJQUFJLFNBQVMsR0FBRyxFQUFFLENBQUM7UUFDbkIsSUFBRyxLQUFLLEdBQUcsQ0FBQyxFQUFDO1lBQ1gsU0FBUyxHQUFHLEtBQUssR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQSxDQUFDLENBQUEsRUFBRSxHQUFFLEtBQUssR0FBQyxHQUFHLENBQUE7U0FDM0M7UUFDRCxpQkFBaUI7UUFDZixTQUFTLElBQUksQ0FBQyxLQUFLLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUEsQ0FBQyxDQUFBLEVBQUUsQ0FBQyxHQUFFLEtBQUssR0FBQyxJQUFJLENBQUE7UUFDOUMsU0FBUyxJQUFJLENBQUMsS0FBSyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsR0FBRyxDQUFBLENBQUMsQ0FBQSxFQUFFLENBQUMsR0FBRSxLQUFLLEdBQUMsR0FBRyxDQUFBO1FBQzdDLFNBQVMsSUFBSSxDQUFDLEtBQUssR0FBRyxFQUFFLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQSxDQUFDLENBQUEsRUFBRSxDQUFDLEdBQUUsS0FBSyxHQUFDLEdBQUcsQ0FBQTtRQUMvQyxJQUFJO1FBQ0osT0FBTyxTQUFTLENBQUU7SUFDcEIsQ0FBQzs7dUdBckJVLFNBQVM7cUdBQVQsU0FBUzs0RkFBVCxTQUFTO2tCQUhyQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxPQUFPO2lCQUNkIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQFBpcGUoe1xyXG4gIG5hbWU6ICdjb3VudCdcclxufSlcclxuZXhwb3J0IGNsYXNzIENvdW50UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xyXG5cclxuICB0cmFuc2Zvcm0odmFsdWU6IGFueSwgLi4uYXJnczogYW55W10pOiBhbnkge1xyXG4gICAgaWYoIXZhbHVlKSByZXR1cm4gdmFsdWU7XHJcbiAgICBpZih0eXBlb2YgdmFsdWUgIT09ICdudW1iZXInKSB7XHJcbiAgICAgIHRocm93IG5ldyBFcnJvcignSW52YWxpZCBwaXBlIGFyZ3VtZW50IGZvciBXZWxjb21lUGlwZScpO1xyXG4gICAgfVxyXG4gICAgbGV0IGxlZnRkID0gTWF0aC5mbG9vcih2YWx1ZS8oMTAwMCo2MCo2MCoyNCkpLCAgLy/orqHnrpflpKnmlbBcclxuICAgIGxlZnRoID0gTWF0aC5mbG9vcih2YWx1ZS8oMTAwMCo2MCo2MCklMjQpLCAgLy/orqHnrpflsI/ml7bmlbBcclxuICAgIGxlZnRtID0gTWF0aC5mbG9vcih2YWx1ZS8oMTAwMCo2MCklNjApLCAgLy/orqHnrpfliIbpkp/mlbBcclxuICAgIGxlZnRzID0gTWF0aC5mbG9vcih2YWx1ZS8xMDAwJTYwKTsgIC8v6K6h566X56eS5pWwXHJcbiAgICBsZXQgcmV0dXJuU3RyID0gXCJcIjtcclxuICAgIGlmKGxlZnRkID4gMCl7XHJcbiAgICAgIHJldHVyblN0ciA9IGxlZnRkIDwgMTAgPyBcIjBcIjpcIlwiICtsZWZ0ZCtcIuWkqVwiXHJcbiAgICB9XHJcbiAgICAvLyBpZihsZWZ0aCA+IDApe1xyXG4gICAgICByZXR1cm5TdHIgKz0gKGxlZnRoIDwgMTAgPyBcIjBcIjpcIlwiKSArbGVmdGgrXCLlsI/ml7ZcIlxyXG4gICAgICByZXR1cm5TdHIgKz0gKGxlZnRtIDwgMTAgPyBcIjBcIjpcIlwiKSArbGVmdG0rXCLliIZcIlxyXG4gICAgICByZXR1cm5TdHIgKz0gKGxlZnRzIDwgMTAgPyBcIjBcIjpcIlwiKSArbGVmdHMrXCLnp5JcIlxyXG4gICAgLy8gfVxyXG4gICAgcmV0dXJuIHJldHVyblN0ciA7XHJcbiAgfVxyXG5cclxufVxyXG4iXX0=

package/esm2020/core/pipe/day.pipe.mjs

@@ -0,0 +1,24 @@
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DayPipe {
+    constructor() {
+        this.TIME_OF_DAY = 24 * 60 * 60 * 1000;
+    }
+    transform(value, ...args) {
+        if (!value)
+            return value;
+        if (typeof value !== 'number') {
+            throw new Error('Invalid pipe argument for WelcomePipe');
+        }
+        return parseInt(value / this.TIME_OF_DAY + "");
+    }
+}
+DayPipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DayPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+DayPipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DayPipe, name: "day" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: DayPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'day'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF5LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9jb3JlL3BpcGUvZGF5LnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBS3BELE1BQU0sT0FBTyxPQUFPO0lBSHBCO1FBSUUsZ0JBQVcsR0FBVSxFQUFFLEdBQUMsRUFBRSxHQUFDLEVBQUUsR0FBQyxJQUFJLENBQUM7S0FVcEM7SUFSQyxTQUFTLENBQUMsS0FBVSxFQUFFLEdBQUcsSUFBVztRQUNsQyxJQUFHLENBQUMsS0FBSztZQUFFLE9BQU8sS0FBSyxDQUFDO1FBQ3hCLElBQUcsT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO1lBQzVCLE1BQU0sSUFBSSxLQUFLLENBQUMsdUNBQXVDLENBQUMsQ0FBQztTQUMxRDtRQUNELE9BQU8sUUFBUSxDQUFDLEtBQUssR0FBQyxJQUFJLENBQUMsV0FBVyxHQUFDLEVBQUUsQ0FBQyxDQUFFO0lBQzlDLENBQUM7O3FHQVRVLE9BQU87bUdBQVAsT0FBTzs0RkFBUCxPQUFPO2tCQUhuQixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxLQUFLO2lCQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQFBpcGUoe1xyXG4gIG5hbWU6ICdkYXknXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBEYXlQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XHJcbiAgVElNRV9PRl9EQVk6bnVtYmVyID0gMjQqNjAqNjAqMTAwMDtcclxuXHJcbiAgdHJhbnNmb3JtKHZhbHVlOiBhbnksIC4uLmFyZ3M6IGFueVtdKTogYW55IHtcclxuICAgIGlmKCF2YWx1ZSkgcmV0dXJuIHZhbHVlO1xyXG4gICAgaWYodHlwZW9mIHZhbHVlICE9PSAnbnVtYmVyJykge1xyXG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0ludmFsaWQgcGlwZSBhcmd1bWVudCBmb3IgV2VsY29tZVBpcGUnKTtcclxuICAgIH1cclxuICAgIHJldHVybiBwYXJzZUludCh2YWx1ZS90aGlzLlRJTUVfT0ZfREFZK1wiXCIpIDtcclxuICB9XHJcblxyXG59XHJcbiJdfQ==