From 8a87cf3705d1f2cb316ad86b2e33b8c48f5038ef Mon Sep 17 00:00:00 2001
From: AlexeyOplachko <xirenec1@gmail.com>
Date: Fri, 9 Feb 2024 19:05:51 +0200
Subject: [PATCH 1/8] fix: copy from a flow popup

# Conflicts:
#	src/components/SimplePanel.tsx
---
 src/components/SimplePanel.tsx | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/components/SimplePanel.tsx b/src/components/SimplePanel.tsx
index 4d8e5f4..a6434d8 100644
--- a/src/components/SimplePanel.tsx
+++ b/src/components/SimplePanel.tsx
@@ -112,8 +112,19 @@ export const DetaiItem: React.FC<any> = ({ item, theme }: any): JSX.Element | nu
   try {
     isJSON = typeof JSON.parse(value) === 'object';
   } catch (e) { }
+  const textAreaRef: any = useRef(null);
 
+  function copyToClipboard() {
+    if (textAreaRef && textAreaRef.current) {
+      textAreaRef.current.focus();
+      textAreaRef.current.select();
+      document.execCommand('copy');
+    }
+  };
+  const [copyValue, setCopyValue] = useState('')
   return (<div>
+    <textarea
+      ref={textAreaRef} value={copyValue} style={{pointerEvents: 'none', opacity: 0, position: 'fixed', left: 0, top: 0, border: 0, padding: 0 }} />
     {value ? <>
       <strong className={styles.label}>{key}</strong>
       {isJSON ?
@@ -125,6 +136,14 @@ export const DetaiItem: React.FC<any> = ({ item, theme }: any): JSX.Element | nu
             displayObjectSize={false}
             enableClipboard={({ src }) => {
               navigator.clipboard.writeText(JSON.stringify(src))
+              if (navigator.clipboard) {
+                navigator.clipboard.writeText(JSON.stringify(src))
+              } else {
+                setCopyValue(JSON.stringify(src))
+                setTimeout(() => {
+                  copyToClipboard()
+                }, 0);
+              }
             }}
             quotesOnKeys={false}
             name={false}

From cd97972e65a510c0369be173224c84e52a28e112 Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Thu, 15 Feb 2024 10:04:08 +0200
Subject: [PATCH 2/8] feat: export as txt and as png

# Conflicts:
#	ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
#	src/components/SimplePanel.tsx
---
 .../ngx-flow/src/lib/ngx-flow.component.ts    |  24 +-
 .../src/tab-flow/tab-flow.component.html      | 226 ++++----
 .../src/tab-flow/tab-flow.component.ts        |  64 ++-
 src/components/SimplePanel.tsx                | 490 ++++++++++--------
 4 files changed, 413 insertions(+), 391 deletions(-)

diff --git a/ngx-flow/projects/ngx-flow/src/lib/ngx-flow.component.ts b/ngx-flow/projects/ngx-flow/src/lib/ngx-flow.component.ts
index b24d40d..5cd0425 100644
--- a/ngx-flow/projects/ngx-flow/src/lib/ngx-flow.component.ts
+++ b/ngx-flow/projects/ngx-flow/src/lib/ngx-flow.component.ts
@@ -13,6 +13,18 @@ import { FlowData } from '../models/flow.model';
             [callid]="callid"
             [isSimplify]="isSimplify"
         ></app-tab-flow>
+        <div style="position: relative; overflow: hidden; height: 1px; width: 1px;">
+                        <div style="position: absolute;">
+                            <app-tab-flow 
+            [callid]="callid"
+            [dataItem]="{data: _formattedData}"
+                            [exportAsPNG]="exportAsPNG" 
+                            [callIDColorList]='callIDColorList'
+                            (pngReady)="exportAsPNG=false"
+                            >
+                            </app-tab-flow>
+                        </div>
+                    </div>
     </div>`,
     styles: [`
     .wrapper-container {
@@ -30,8 +42,12 @@ export class NgxFlowComponent implements OnInit {
     @Input() callid: any;
     @Input() isSimplify: boolean = false;
     @Input() isFilter: boolean = false;
-
-    constructor() { }
+    exportAsPNG: boolean = false;
+    constructor() {
+        document.addEventListener('export-flow-as-png', (e: any) => {
+            this.exportAsPNG = true
+        });
+    }
 
     ngOnInit(): void {
         console.log(this.data)
@@ -69,14 +85,14 @@ export class NgxFlowComponent implements OnInit {
         const dist = hosts.find((i: any) => i.name === DIST);
 
         return {
-            callid: hash((i.messageID || i.title)+''),
+            callid: hash((i.messageID || i.title) + ''),
             codecData: ' ',
             description: i.aboveArrow || '',
             destination_ip: dist.ip,
             destination_port: dist.port,
             diff: ' ',
             diff_absolute: i.subTitle || '',
-            diff_num:  ' ',
+            diff_num: ' ',
             dstAlias: DIST,
             id: 0,
             info_date: i.belowArrow || '... ',
diff --git a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
index 42b04d4..60d5f76 100644
--- a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
+++ b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
@@ -1,156 +1,106 @@
-<div
-  class="flowscreen"
-  [style.min-width.px]="pageWidth + 85"
-  data-comment="85 = 16 * 2 + 106 / 2"
-  [style.padding-top.px]="isExport ? 40 : 0"
-  [style.width]="isExport ? 'calc(100% + 20px)' : 'calc(100% - 1rem)'"
-  #flowscreen
->
-  <ng-container *ngIf="arrayItemsVisible?.length === 0">
-    <h1 style="text-align: center; padding: 8rem; color: #aaa">No Data</h1>
-  </ng-container>
+<div class="flowscreen" [style.min-width.px]="pageWidth + 85" data-comment="85 = 16 * 2 + 106 / 2"
+    [style.padding-top.px]="isExport ? 40 : 0" [style.width]="isExport ? 'calc(100% + 20px)' : 'calc(100% - 1rem)'"
+    #flowscreen>
+    <ng-container *ngIf="arrayItemsVisible?.length === 0">
+        <h1 style="text-align: center; padding: 8rem; color: #aaa">No Data</h1>
+    </ng-container>
 
-  <div class="flow-grid-lines" [style.min-width.px]="pageWidth - 16 * 2">
-    <div *ngFor="let title of flowGridLines" class="line"></div>
-  </div>
+    <div class="flow-grid-lines" [style.min-width.px]="pageWidth - 16 * 2">
+        <div *ngFor="let title of flowGridLines" class="line"></div>
+    </div>
 
-  <!-- hosts -->
+    <!-- hosts -->
 
-  <div class="hosts" [style.top.px]="isExport ? 40 : 0">
-    <div class="hosts-wrapper">
-      <!-- host titles -->
-      <ng-template ngFor let-itemhost [ngForOf]="_isCombineByAlias ? hostsCA : hostsIPs">
-        <div *ngIf="!itemhost.hidden" [ngClass]="'item-wrapper' + (isSimplify ? ' big' : '')">
-          <!-- wrapper -->
+    <div class="hosts" [style.top.px]="isExport ? 40 : 0">
+        <div class="hosts-wrapper">
+            <!-- host titles -->
+            <ng-template ngFor let-itemhost [ngForOf]="_isCombineByAlias ? hostsCA : hostsIPs">
+                <div *ngIf="!itemhost.hidden" [ngClass]="'item-wrapper' + (isSimplify ? ' big' : '')">
+                    <!-- wrapper -->
 
-          <div
-            class="item"
-            [id]="itemhost.alias && itemhost.alias !== itemhost.ip ? itemhost.alias : ''"
-            [style.border-color]="(itemhost.color && itemhost.color.border) || 'lightgray'"
-          >
-            <!-- container -->
+                    <div class="item" [id]="itemhost.alias && itemhost.alias !== itemhost.ip ? itemhost.alias : ''"
+                        [style.border-color]="(itemhost.color && itemhost.color.border) || 'lightgray'">
+                        <!-- container -->
 
-            <div class="aliasfield" (mouseover)="showTooltip(itemhost)" (mouseout)="hideTooltip()">
-              <ng-template #noAlias> </ng-template>
-              <div class="alias-img"></div>
-              <div class="alias-name" *ngIf="!_isCombineByAliasGroup; else itemhostGroup">
-                {{ itemhost.alias && itemhost.alias !== itemhost.ip ? itemhost.alias : '' }}
-              </div>
-              <ng-template #itemhostGroup>
-                <div>Group:</div>
-                <div class="alias-name">
-                  {{ itemhost.group || '...other...' }}
+                        <div class="aliasfield" (mouseover)="showTooltip(itemhost)" (mouseout)="hideTooltip()">
+                            <ng-template #noAlias> </ng-template>
+                            <div class="alias-img"></div>
+                            <div class="alias-name" *ngIf="!_isCombineByAliasGroup; else itemhostGroup">
+                                {{ itemhost.alias && itemhost.alias !== itemhost.ip ? itemhost.alias : '' }}
+                            </div>
+                            <ng-template #itemhostGroup>
+                                <div>Group:</div>
+                                <div class="alias-name">
+                                    {{ itemhost.group || '...other...' }}
+                                </div>
+                            </ng-template>
+                        </div>
+                    </div>
                 </div>
-              </ng-template>
-            </div>
-          </div>
+            </ng-template>
         </div>
-      </ng-template>
     </div>
-  </div>
 
-  <!-- flow packets -->
-  <!-- REAL TIME FLOW -->
+    <!-- flow packets -->
+    <!-- REAL TIME FLOW -->
 
-  <!-- EXPORT FLOW as PNG -->
-  <div
-    *ngIf="isExport"
-    class="flow-packets-wrapper"
-    [style.margin-right.rem]="0"
-    [style.min-width.px]="pageWidth + 100"
-  >
-    <div style="height: 92px"></div>
-    <app-flow-item
-      *ngFor="let item of arrayItemsVisible; let idx = index"
-      [isGroupByAlias]="_isCombineByAlias"
-      [item]="item"
-      [idx]="idx"
-      [isSimplify]="false"
-    >
-    </app-flow-item>
-    <div style="height: 40px"></div>
-  </div>
-  <!-- </div> -->
-  <div *ngIf="isExport" class="label-callid-container">
-    <div class="label-callid-wrapper" *ngFor="let itemLabel of labels" [style.color]="itemLabel.color">
-      * {{ itemLabel.callid }}
+    <!-- EXPORT FLOW as PNG -->
+    <div *ngIf="isExport" class="flow-packets-wrapper" [style.margin-right.rem]="0"
+        [style.min-width.px]="pageWidth + 100">
+        <div style="height: 92px"></div>
+        <app-flow-item *ngFor="let item of arrayItemsVisible; let idx = index" [isGroupByAlias]="_isCombineByAlias"
+            [item]="item" [idx]="idx" [isSimplify]="false">
+        </app-flow-item>
+        <div style="height: 40px"></div>
+    </div>
+    <!-- </div> -->
+    <div *ngIf="isExport" class="label-callid-container">
+        <div class="label-callid-wrapper" *ngFor="let itemLabel of labels" [style.color]="itemLabel.color">
+            * {{ itemLabel.callid }}
+        </div>
     </div>
-  </div>
 </div>
 <div class="VS-Container-horizontal">
-  <div
-    class="VS-Container"
-    style="overflow: auto !important"
-    (scroll)="onScrollVScrollWrapper($event)"
-  >
-    <div
-      class="VS-Container"
-      style="height: initial; overflow: scroll !important"
-      [style.min-width.px]="pageWidth + 100"
-    >
-      <div style="height: 92px"></div>
-      <app-flow-item
-        *ngFor="let item of arrayItems; let idx = index"
-        [item]="item"
-        [idx]="idx"
-        [isGroupByAlias]="_isCombineByAlias"
-        [isSimplify]="isSimplify"
-        [isAbsolute]="isAbsolute"
-        (itemClick)="onClickMessage($event.idx, $event.event, item)"
-      ></app-flow-item>
-      <div style="height: 60px"></div>
+    <div *ngIf="isExport || isSafari" class="VS-Container" style="overflow: auto !important"
+        (scroll)="onScrollVScrollWrapper($event)">
+        <div class="VS-Container" style="height: initial; overflow: scroll !important; bottom:unset"
+            [style.min-width.px]="pageWidth + 100">
+            <div style="height: 92px"></div>
+            <app-flow-item *ngFor="let item of arrayItems; let idx = index" [item]="item" [idx]="idx"
+                [isGroupByAlias]="_isCombineByAlias" [isSimplify]="isSimplify" [isAbsolute]="isAbsolute"
+                (itemClick)="onClickMessage($event.idx, $event.event, item)"></app-flow-item>
+            <div style="height: 60px"></div>
+        </div>
+    </div>
+    <div class="VS-Container" style="overflow-y: hidden !important" (scroll)="onScrollVScrollWrapper($event)"
+        *ngIf="!isExport && !isSafari" #VScrollWrapper>
+        <cdk-virtual-scroll-viewport class="VS-Container hidescroll" (wheel)="cdkWheelScroll($event)"
+            (touchstart)="onEvent($event, 'touchstart')" (touchmove)="onEvent($event, 'touchmove')" [maxBufferPx]="500"
+            [minBufferPx]="10" [style.min-width.px]="pageWidth + 100" #virtualScroll>
+            <ng-container *cdkVirtualFor="let item of virtualScrollerItemsArray; let idx = index"
+                [ngSwitch]="item?._step">
+                <ng-template ngSwitchCase="top">
+                    <div style="height: 92px"></div>
+                </ng-template>
+                <ng-template ngSwitchDefault>
+                    <app-flow-item [item]="item" [idx]="idx" [isGroupByAlias]="_isCombineByAlias"
+                        [isSimplify]="isSimplify" [isAbsolute]="isAbsolute"
+                        (itemClick)="onClickMessage($event.idx, $event.event, item)">
+                    </app-flow-item>
+                </ng-template>
+                <ng-template ngSwitchCase="bottom">
+                    <div style="height: 60px"></div>
+                </ng-template>
+            </ng-container>
+        </cdk-virtual-scroll-viewport>
     </div>
-  </div>
-  <!-- <div
-    class="VS-Container"
-    style="overflow-y: hidden !important"
-    (scroll)="onScrollVScrollWrapper($event)"
-    *ngIf="!isExport"
-    #VScrollWrapper
-  >
-    <cdk-virtual-scroll-viewport
-      class="VS-Container hidescroll"
-      (wheel)="cdkWheelScroll($event)"
-      (touchstart)="onEvent($event, 'touchstart')"
-      (touchmove)="onEvent($event, 'touchmove')"
-      [maxBufferPx]="500"
-      [minBufferPx]="10"
-      [style.min-width.px]="pageWidth + 100"
-      #virtualScroll
-    >
-      <ng-container *cdkVirtualFor="let item of virtualScrollerItemsArray; let idx = index" [ngSwitch]="item?._step">
-        <ng-template ngSwitchCase="top">
-          <div style="height: 92px"></div>
-        </ng-template>
-        <ng-template ngSwitchDefault>
-          <app-flow-item
-            [item]="item"
-            [idx]="idx"
-            [isGroupByAlias]="_isCombineByAlias"
-            [isSimplify]="isSimplify"
-            [isAbsolute]="isAbsolute"
-            (itemClick)="onClickMessage($event.idx, $event.event, item)"
-          >
-          </app-flow-item>
-        </ng-template>
-        <ng-template ngSwitchCase="bottom">
-          <div style="height: 60px"></div>
-        </ng-template>
-      </ng-container>
-    </cdk-virtual-scroll-viewport>
-  </div> -->
 </div>
 
 <div id="download" style="display: none">
-  <img #canvas />
-  <a #downloadLink></a>
+    <img #canvas />
+    <a #downloadLink target="_blank"></a>
 </div>
-<!-- <div
-  class="virtual-scrollbar"
-  *ngIf="!isExport"
-  (mousedown)="setScrollTarget('virtualScrollbar')"
-  (scroll)="setVirtualScrollHeight($event)"
-  #virtualScrollbar
->
-  <div [style.transform]="getVirtualScrollHeight" [style.padding.px]="1"></div>
-</div> -->
+<div class="virtual-scrollbar" *ngIf="!isExport && !isSafari" (mousedown)="setScrollTarget('virtualScrollbar')"
+    (scroll)="setVirtualScrollHeight($event)" #virtualScrollbar>
+    <div [style.transform]="getVirtualScrollHeight" [style.padding.px]="1"></div>
+</div>
diff --git a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
index 7760f75..6d9798d 100644
--- a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
+++ b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
@@ -16,6 +16,7 @@ import {
 } from '../services/message-details.service';
 import { Subscription } from 'rxjs';
 import { isExternalUrl } from '../helpers/functions';
+import * as html2canvas from 'html2canvas';
 
 export class CustomVirtualScrollStrategy extends FixedSizeVirtualScrollStrategy {
     constructor() {
@@ -123,7 +124,7 @@ export class TabFlowComponent
                 dataItemValue = {
                     data: JSON.parse(dataItemValueInput)
                 }
-            } catch (e)  {
+            } catch (e) {
                 console.error("JSON PARSING ERROR", e, dataItemValueInput)
                 dataItemValue = {
                     data: null
@@ -137,7 +138,7 @@ export class TabFlowComponent
                     try {
                         console.log(JSON_parse(dataItemValueInput.data),JSON.parse(dataItemValueInput.data))
                         dataItemValue.data = JSON.parse(dataItemValueInput.data)
-                    } catch (e)  {
+                    } catch (e) {
                         console.error("JSON PARSING ERROR", e, dataItemValueInput.data)
                         dataItemValue = {
                             data: null
@@ -216,7 +217,7 @@ export class TabFlowComponent
         if (val) {
             this.isExport = true;
             this.cdr.detectChanges();
-            // setTimeout(this.onSavePng.bind(this), 500);
+            setTimeout(this.onSavePng.bind(this), 500);
         }
     }
 
@@ -235,7 +236,10 @@ export class TabFlowComponent
         private messageDetailsService: MessageDetailsService,
         private transactionFilterService: TransactionFilterService,
         private cdr: ChangeDetectorRef,
-    ) { }
+    ) {
+        console.log('test constructor')
+
+    }
     public isDataReady() {
 
     }
@@ -589,8 +593,28 @@ export class TabFlowComponent
         const arr = itemhost.arrip || [itemhost.IP];
         return arr.join(', ');
     }
-    // onSavePng() {
-
+    onSavePng() {
+        if (!this._flagAfterViewInit) {
+            setTimeout(this.onSavePng.bind(this), 1000);
+            return;
+        }
+        if (html2canvas && typeof html2canvas === 'function') {
+            this.cdr.detectChanges();
+            const f: Function = html2canvas as Function;
+            f(this.flowscreen.nativeElement).then((canvas: any) => {
+                this.canvas.nativeElement.src = canvas.toDataURL();
+                this.downloadLink.nativeElement.href = canvas.toDataURL('image/png');
+                const date = new Date();
+                this.downloadLink.nativeElement.download = `${date.toUTCString()}.png`;
+                console.log()
+                this.downloadLink.nativeElement.click();
+                console.log('%cpng ready', 'color:#ff4400; font-size: 50px;', this.downloadLink.nativeElement.href);
+                setTimeout(() => {
+                    this.pngReady.emit({});
+                });
+            });
+        }
+    }
     labelColor(callid: any, selected: any) {
         if (selected) {
             const color = this.callIDColorList?.find(
@@ -623,20 +647,20 @@ export class TabFlowComponent
         this.copyTimer = Date.now();
     }
     copy(value: any) {
-    //   const localTimer = Date.now();
-    //   if (localTimer - this.copyTimer > 700) {
-    //     this.copyService.copy(value.callid, {
-    //       message: 'notifications.success.callidCopy',
-    //       isTranslation: true,
-    //       translationParams: {
-    //         callid: value.callid,
-    //       },
-    //     });
-    //     value.copySelected = true;
-    //     this.timeout = setTimeout(() => {
-    //       value.copySelected = false;
-    //     }, 1800);
-    //   }
+        //   const localTimer = Date.now();
+        //   if (localTimer - this.copyTimer > 700) {
+        //     this.copyService.copy(value.callid, {
+        //       message: 'notifications.success.callidCopy',
+        //       isTranslation: true,
+        //       translationParams: {
+        //         callid: value.callid,
+        //       },
+        //     });
+        //     value.copySelected = true;
+        //     this.timeout = setTimeout(() => {
+        //       value.copySelected = false;
+        //     }, 1800);
+        //   }
     }
     setScrollTarget(targetString: string) {
         this.ScrollTarget = targetString;
diff --git a/src/components/SimplePanel.tsx b/src/components/SimplePanel.tsx
index a6434d8..85732ff 100644
--- a/src/components/SimplePanel.tsx
+++ b/src/components/SimplePanel.tsx
@@ -1,4 +1,4 @@
-import React from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { PanelProps, StandardEditorProps } from '@grafana/data';
 import { SimpleOptions } from 'types';
 import { css, cx } from '@emotion/css';
@@ -6,13 +6,13 @@ import './../../ngx-flow/widget/ngx-flow.js';
 import ReactJson from 'react-json-view';
 
 import {
-  Button,
-  MultiSelect,
-  Collapse,
-  // AsyncSelect,
-  Modal,
-  useStyles2,
-  useTheme2
+    Button,
+    MultiSelect,
+    Collapse,
+    // AsyncSelect,
+    Modal,
+    useStyles2,
+    useTheme2
 } from '@grafana/ui';
 
 
@@ -22,273 +22,305 @@ interface Props extends PanelProps<SimpleOptions> { }
 type CustomElement<T> = Partial<T & React.DOMAttributes<T> & { children: any }>;
 
 declare global {
-  /* eslint-disable-next-line */
-  namespace JSX {
-    interface IntrinsicElements {
-      ['ngx-flow-out']: CustomElement<any>;
+    /* eslint-disable-next-line */
+    namespace JSX {
+        interface IntrinsicElements {
+            ['ngx-flow-out']: CustomElement<any>;
+        }
     }
-  }
 }
 export let valueLabelsName: string[] = [];
 let bufferCheck = '';
 export const TemplateEditor = ({ value, onChange }: StandardEditorProps<string>) => {
-  const [isOpen, setIsOpen] = React.useState(false);
-  const themeName: string = useTheme2().name;
-  const styles = useStyles2(getStyles);
-  const templateData = JSON.stringify({
-    actors: [], data: [{
-      messageID: 'messageID',
-      subTitle: 'subTitle',
-      source: 'source',
-      destination: 'destination',
-      title: 'title',
-      aboveArrow: 'aboveArrow',
-      belowArrow: 'belowArrow',
-      sourceLabel: 'sourceLabel',
-      destinationLabel: 'destinationLabel',
-    }]
-  });
-  return <Collapse label="Template" isOpen={isOpen} onToggle={() => setIsOpen(!isOpen)}>
-    <div className={cx(
-      styles.wrapper, css`
+    const [isOpen, setIsOpen] = React.useState(false);
+    const themeName: string = useTheme2().name;
+    const styles = useStyles2(getStyles);
+
+    const templateData = JSON.stringify({
+        actors: [], data: [{
+            messageID: 'messageID',
+            subTitle: 'subTitle',
+            source: 'source',
+            destination: 'destination',
+            title: 'title',
+            aboveArrow: 'aboveArrow',
+            belowArrow: 'belowArrow',
+            sourceLabel: 'sourceLabel',
+            destinationLabel: 'destinationLabel',
+        }]
+    });
+    return <Collapse label="Template" isOpen={isOpen} onToggle={() => setIsOpen(!isOpen)}>
+        <div className={cx(
+            styles.wrapper, css`
     height: 250px;
     `)}>
-      <ngx-flow-out data-flow={templateData} theme={themeName} />
-    </div>
-  </Collapse>;
+            <ngx-flow-out data-flow={templateData} theme={themeName} />
+        </div>
+    </Collapse>;
 }
 export const SimpleEditor = ({ value, onChange }: StandardEditorProps<string[]>) => {
-  const [selectValue, setSelectValue] = React.useState<any>();
-  const [forRerender, setForRerender] = React.useState<any>(0);
-
-  if (bufferCheck !== JSON.stringify(valueLabelsName) || valueLabelsName?.length === 0) {
-    setTimeout(() => {
-      bufferCheck = JSON.stringify(valueLabelsName)
-      setSelectValue(value);
-      setForRerender(forRerender + 1);
-    }, 200)
-  }
-
-  return <MultiSelect
-    options={valueLabelsName.map((i: any) => ({ label: i, value: i }))}
-    value={selectValue}
-    onChange={(v: any[]) => {
-      setSelectValue(v);
-      onChange(v.map((j: any) => j.value));
-    }}
-  />;
+    const [selectValue, setSelectValue] = React.useState<any>();
+    const [forRerender, setForRerender] = React.useState<any>(0);
+
+    if (bufferCheck !== JSON.stringify(valueLabelsName) || valueLabelsName?.length === 0) {
+        setTimeout(() => {
+            bufferCheck = JSON.stringify(valueLabelsName)
+            setSelectValue(value);
+            setForRerender(forRerender + 1);
+        }, 200)
+    }
+
+    return <MultiSelect
+        options={valueLabelsName.map((i: any) => ({ label: i, value: i }))}
+        value={selectValue}
+        onChange={(v: any[]) => {
+            setSelectValue(v);
+            onChange(v.map((j: any) => j.value));
+        }}
+    />;
 };
 
 const getStyles = () => {
-  return {
-    wrapper: css`
+    return {
+        wrapper: css`
       font-family: Open Sans;
       position: relative;
     `,
-    textBox: css`
+        textBox: css`
       position: absolute;
       bottom: 0;
       left: 0;
       padding: 10px;
     `,
-    label: css`
+        label: css`
       background-color: rgba(128, 128, 128, 0.1);
     `,
-    pre: css`
+        pre: css`
       white-space: pre-wrap;
     `
-  };
+    };
 };
 
 export const DetaiItem: React.FC<any> = ({ item, theme }: any): JSX.Element | null => {
-  let [key, value]: any = item;
-  const themeName: any = theme === 'Dark' ? 'railscasts' : 'rjv-default'
-  let isJSON = false;
-  const styles = useStyles2(getStyles);
-  const isTimestamp = (new Date(value)).getTime() > 0;
-  if (isTimestamp) {
-    value = `${new Date(value).toISOString()} | ${value}`;
-  }
-  try {
-    isJSON = typeof JSON.parse(value) === 'object';
-  } catch (e) { }
-  const textAreaRef: any = useRef(null);
-
-  function copyToClipboard() {
-    if (textAreaRef && textAreaRef.current) {
-      textAreaRef.current.focus();
-      textAreaRef.current.select();
-      document.execCommand('copy');
+    let [key, value]: any = item;
+    const themeName: any = theme === 'Dark' ? 'railscasts' : 'rjv-default'
+    let isJSON = false;
+    const styles = useStyles2(getStyles);
+    const isTimestamp = (new Date(value)).getTime() > 0;
+    if (isTimestamp) {
+        value = `${new Date(value).toISOString()} | ${value}`;
     }
-  };
-  const [copyValue, setCopyValue] = useState('')
-  return (<div>
-    <textarea
-      ref={textAreaRef} value={copyValue} style={{pointerEvents: 'none', opacity: 0, position: 'fixed', left: 0, top: 0, border: 0, padding: 0 }} />
-    {value ? <>
-      <strong className={styles.label}>{key}</strong>
-      {isJSON ?
-        <pre>
-          <ReactJson
-            src={JSON.parse(value)}
-            theme={themeName}
-            displayDataTypes={false}
-            displayObjectSize={false}
-            enableClipboard={({ src }) => {
-              navigator.clipboard.writeText(JSON.stringify(src))
-              if (navigator.clipboard) {
-                navigator.clipboard.writeText(JSON.stringify(src))
-              } else {
-                setCopyValue(JSON.stringify(src))
-                setTimeout(() => {
-                  copyToClipboard()
-                }, 0);
-              }
-            }}
-            quotesOnKeys={false}
-            name={false}
-
-          />
-        </pre> :
-        <pre className={styles.pre}>{value}</pre>
-      }
-    </> : <>
-    </>}
-
-  </div>);
+    try {
+        isJSON = typeof JSON.parse(value) === 'object';
+    } catch (e) { }
+    const textAreaRef: any = useRef(null);
+
+    function copyToClipboard() {
+        if (textAreaRef && textAreaRef.current) {
+            textAreaRef.current.focus();
+            textAreaRef.current.select();
+            document.execCommand('copy');
+        }
+    };
+    const [copyValue, setCopyValue] = useState('')
+    return (<div>
+        <textarea
+            ref={textAreaRef} value={copyValue} style={{ pointerEvents: 'none', opacity: 0, position: 'fixed', left: 0, top: 0, border: 0, padding: 0 }} />
+        {value ? <>
+            <strong className={styles.label}>{key}</strong>
+            {isJSON ?
+                <pre>
+                    <ReactJson
+                        src={JSON.parse(value)}
+                        theme={themeName}
+                        displayDataTypes={false}
+                        displayObjectSize={false}
+                        enableClipboard={({ src }) => {
+                            if (navigator.clipboard) {
+                                navigator.clipboard.writeText(JSON.stringify(src))
+                            } else {
+                                setCopyValue(JSON.stringify(src))
+                                setTimeout(() => {
+                                    copyToClipboard()
+                                }, 0);
+                            }
+                        }}
+                        quotesOnKeys={false}
+                        name={false}
+
+                    />
+                </pre> :
+                <pre className={styles.pre}>{value}</pre>
+            }
+        </> : <>
+        </>}
+
+    </div>);
 }
 let ngxFlowClickHandler: Function = function () { };
 
 document.addEventListener('ngx-flow-click-item', function (e: any) {
-  // console.log('ngx-flow-click-item::details');
-  ngxFlowClickHandler(e)
+    // console.log('ngx-flow-click-item::details');
+    ngxFlowClickHandler(e)
 });
 
 function formattingDataAndSortIt(data: any, sortType = 'none') {
-  const [firstField] = data || [];
-  const unSortData = firstField?.values?.map((i: any, k: number) => {
-    const outData: any = {};
-    data.forEach((item: any) => {
-      outData[item.name] = item?.values?.[k];
+
+    let [firstField] = data || [];
+
+    const unSortData = firstField?.values?.map((i: any, k: number) => {
+        const outData: any = {};
+        data.forEach((item: any) => {
+            outData[item.name] = item?.values?.[k];
+        });
+        if (outData?.Time && typeof outData?.labels === 'object') {
+            outData['labels'].timestamp = outData.Time;
+        }
+        return outData;
+    }) || [];
+    if (sortType === 'none') {
+        return unSortData;
+    }
+    const sortData = unSortData.sort((itemA: any, itemB: any) => {
+        if (itemA.tsNs && itemB.tsNs) {
+            const a = itemA.tsNs;
+            const b = itemB.tsNs;
+            return a < b ? -1 : a > b ? 1 : 0;
+        } else {
+            const a = itemA.Time;
+            const b = itemB.Time;
+            return a < b ? -1 : a > b ? 1 : 0;
+        }
     });
-    if (outData?.Time && typeof outData?.labels === 'object') {
-      outData['labels'].timestamp = outData.Time;
-    } 
-    return outData;
-  }) || [];
-  if (sortType === 'none') {
-    return unSortData;
-  }
-  const sortData = unSortData.sort((itemA: any, itemB: any) => {
-    if (itemA.tsNs && itemB.tsNs) {
-      const a = itemA.tsNs;
-      const b = itemB.tsNs;
-      return a < b ? -1 : a > b ? 1 : 0;
-    } else { 
-      const a = itemA.Time;
-      const b = itemB.Time;
-      return a < b ? -1 : a > b ? 1 : 0;
+    if (sortType === 'time_old') {
+        return sortData;
     }
-  });
-  if (sortType === 'time_old') {
-    return sortData;
-  }
 
-  if (sortType === 'time_new') {
-    return sortData.reverse();
-  }
+    if (sortType === 'time_new') {
+        return sortData.reverse();
+    }
 
 }
 
 export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: any) => {
-  const [flowData, setFlowData] = React.useState({ actors: [], data: [] });
-  const [modalIsOpen, setModalIsOpen] = React.useState(false);
-  const [modalData, setModalData] = React.useState({});
-  const [modalDataFields, setModalDataFields] = React.useState([]);
-
-  const onModalClose = () => {
-    setModalIsOpen(false);
-  };
-
-  const styles = useStyles2(getStyles);
-  React.useEffect(() => {
-    const [serie]: any = (data as any)?.series || [];
-    const fields = serie?.fields || [];
-    console.log({ options })
-    if (fields) {
-      const [firsField]: any = fields;
-      const sortData = formattingDataAndSortIt(fields, options.sortoption);
-      // console.log({ fields }, sortData);
-      setModalDataFields(sortData);
-      const outData = firsField?.values;
-
-      if (outData) {
-        valueLabelsName = Object.keys(outData?.[0] || {});
-        setFlowData({
-          actors: [], data: sortData.map((item: any) => {
-            const message: string = item.Line || '';
-            const labelItem: any = item.labels || {};
-            const _ = (optionArr: string[] | string) => {
-              if (optionArr instanceof Array) {
-                return optionArr.map((option: string) => labelItem[option]).filter((a: any) => !!a).join(':');
-              }
-              return labelItem[optionArr] || '';
-            };
-            return {
-              messageID: _(options.colorGenerator) || 'Title',
-              subTitle: options.showbody && message,
-              source: _(options.source) || '...',
-              destination: _(options.destination) || '...',
-              title: _(options.title) || '',
-              aboveArrow: _(options.aboveArrow) || '',
-              belowArrow: _(options.belowArrow) || '',
-              sourceLabel: _(options.sourceLabel) || '',
-              destinationLabel: _(options.destinationLabel) || ''
+    const [flowData, setFlowData] = React.useState({ actors: [], data: [] });
+    const [modalIsOpen, setModalIsOpen] = React.useState(false);
+    const [modalData, setModalData] = React.useState({});
+    const [modalDataFields, setModalDataFields] = React.useState([]);
+
+    const onModalClose = () => {
+        setModalIsOpen(false);
+    };
+    useEffect(() => {
+        const handler = (e: any) => {
+
+            const [serie]: any = (data as any)?.series || [];
+            const fields = serie?.fields || [];
+            const lineField = fields.find((i: any) => i.name === 'Line') ?? [];
+            const exportText = lineField?.values.join('\n');
+            // Create element with <a> tag
+            const link = document.createElement("a");
+
+            // Create a blog object with the file content which you want to add to the file
+            const file = new Blob([exportText], { type: 'text/plain' });
+
+            // Add file content in the object URL
+            link.href = URL.createObjectURL(file);
+
+            // Add file name
+            link.download = "sample.txt";
+            console.log(link)
+            // Add click event to <a> tag to save file.
+            link.click();
+            URL.revokeObjectURL(link.href);
+            document.removeChild(link)
+            // console.log(exportText)
+        }
+        document.addEventListener('export-flow-as-text', handler);
+        return () => {
+            document.removeEventListener('export-flow-as-text', handler)
+        }
+    }, [data])
+    const styles = useStyles2(getStyles);
+    React.useEffect(() => {
+        const [serie]: any = (data as any)?.series || [];
+        const fields = serie?.fields || [];
+        console.log({ options })
+        console.log(serie)
+        if (fields) {
+            const [firsField]: any = fields;
+            const sortData = formattingDataAndSortIt(fields, options.sortoption);
+            // console.log({ fields }, sortData);
+            setModalDataFields(sortData);
+            const outData = firsField?.values;
+
+            if (outData) {
+                valueLabelsName = Object.keys(outData?.[0] || {});
+                setFlowData({
+                    actors: [], data: sortData.map((item: any) => {
+                        const message: string = item.Line || '';
+                        const labelItem: any = item.labels || {};
+                        const _ = (optionArr: string[] | string) => {
+                            if (optionArr instanceof Array) {
+                                return optionArr.map((option: string) => labelItem[option]).filter((a: any) => !!a).join(':');
+                            }
+                            return labelItem[optionArr] || '';
+                        };
+                        return {
+                            messageID: _(options.colorGenerator) || 'Title',
+                            subTitle: options.showbody && message,
+                            source: _(options.source) || '...',
+                            destination: _(options.destination) || '...',
+                            title: _(options.title) || '',
+                            aboveArrow: _(options.aboveArrow) || '',
+                            belowArrow: _(options.belowArrow) || '',
+                            sourceLabel: _(options.sourceLabel) || '',
+                            destinationLabel: _(options.destinationLabel) || ''
+                        }
+                    })
+                })
+
             }
-          })
-        })
+        }
+        /* eslint-disable-next-line */
+    }, [data, options]);
 
-      }
-    }
-    /* eslint-disable-next-line */
-  }, [data, options]);
+    ngxFlowClickHandler = (e: any) => {
+        const details: any = modalDataFields[e.detail];
+        if (typeof details.labels === 'object') {
+            details.labels = JSON.stringify(details.labels);
+        }
+        setModalData(details);
+        setModalIsOpen(true);
+    };
 
-  ngxFlowClickHandler = (e: any) => {
-    const details: any = modalDataFields[e.detail];
-    if (typeof details.labels === 'object') {
-      details.labels = JSON.stringify(details.labels);
-    }
-    setModalData(details);
-    setModalIsOpen(true);
-  };
-
-  // console.log(useTheme2());
-  const themeName: string = useTheme2().name;
-  const flowDataJSON = JSON.stringify(flowData);
-  return (
-    <div
-      className={cx(
-        styles.wrapper,
-        css`
+    // console.log(useTheme2());
+    const themeName: string = useTheme2().name;
+    const flowDataJSON = JSON.stringify(flowData);
+    return (
+        <div
+            className={cx(
+                styles.wrapper,
+                css`
           width: ${width}px;
           height: ${height}px;
         `
-      )}
-    >
-      {/* <pre>{JSON.stringify(flowData)}</pre> */}
-      {/* <FlowMemo flowData={flowData} themeName={themeName} /> */}
-      <ngx-flow-out data-flow={flowDataJSON} theme={themeName} />
-
-      <Modal title="Message Details" isOpen={modalIsOpen} onDismiss={onModalClose}>
-        {modalData && Object.entries(modalData).map((item: any, key: number) => (
-          // <p>{item} | {key}</p>
-          <DetaiItem item={item} key={key} theme={themeName} />
-        ))}
-        <Button variant="primary" onClick={onModalClose}>
-          Close
-        </Button>
-      </Modal>
-
-    </div>
-  );
+            )}
+        >
+            {/* <pre>{JSON.stringify(flowData)}</pre> */}
+            {/* <FlowMemo flowData={flowData} themeName={themeName} /> */}
+            <ngx-flow-out data-flow={flowDataJSON} theme={themeName} />
+
+            <Modal title="Message Details" isOpen={modalIsOpen} onDismiss={onModalClose}>
+                {modalData && Object.entries(modalData).map((item: any, key: number) => (
+                    // <p>{item} | {key}</p>
+                    <DetaiItem item={item} key={key} theme={themeName} />
+                ))}
+                <Button variant="primary" onClick={onModalClose}>
+                    Close
+                </Button>
+            </Modal>
+
+        </div>
+    );
 };

From 9d0b782a243a0ce8eb08a1e01c774de1f981e11f Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Tue, 27 Feb 2024 11:00:52 +0200
Subject: [PATCH 3/8] feat: export as pcap

fix: export as pcap

# Conflicts:
#	ngx-flow/package.json
#	package.json
---
 ngx-flow/package.json          |    1 +
 package.json                   |  141 +-
 src/components/SimplePanel.tsx |  161 ++-
 src/libs/packets.js            | 2267 ++++++++++++++++++++++++++++++++
 4 files changed, 2491 insertions(+), 79 deletions(-)
 create mode 100644 src/libs/packets.js

diff --git a/ngx-flow/package.json b/ngx-flow/package.json
index 96be64a..90719f2 100644
--- a/ngx-flow/package.json
+++ b/ngx-flow/package.json
@@ -24,6 +24,7 @@
     "@angular/platform-browser": "~12.2.0",
     "@angular/platform-browser-dynamic": "~12.2.0",
     "@angular/router": "~12.2.0",
+    "html2canvas": "^1.4.1",
     "document-register-element": "^1.7.2",
     "is-in-subnet": "^4.0.1",
     "moment": "^2.29.4",
diff --git a/package.json b/package.json
index 0a64480..ce20818 100644
--- a/package.json
+++ b/package.json
@@ -1,70 +1,75 @@
 {
-  "name": "qxip-flow-panel",
-  "version": "10.0.10",
-  "description": "Test plugin to lern dev enveroument",
-  "scripts": {
-    "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
-    "dev": "webpack -w -c ./.config/webpack/webpack.config.ts --env development",
-    "test": "jest --watch --onlyChanged",
-    "test:ci": "jest --passWithNoTests --maxWorkers 4",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint --cache --ignore-path ./.gitignore --ext .js,.jsx,.ts,.tsx .",
-    "lint:fix": "npm run lint -- --fix",
-    "e2e": "npm exec cypress install && npm exec grafana-e2e run",
-    "e2e:update": "npm exec cypress install && npm exec grafana-e2e run --update-screenshots",
-    "server": "docker-compose up --build",
-    "sign": "npx --yes @grafana/sign-plugin@latest"
-  },
-  "author": "Qxip",
-  "license": "AGPLv3",
-  "devDependencies": {
-    "@babel/core": "^7.21.4",
-    "@grafana/e2e": "^10.0.2",
-    "@grafana/e2e-selectors": "^10.0.2",
-    "@grafana/eslint-config": "^6.0.0",
-    "@grafana/tsconfig": "^1.3.0-rc1",
-    "@swc/core": "^1.3.51",
-    "@swc/helpers": "^0.5.0",
-    "@swc/jest": "^0.2.26",
-    "@testing-library/jest-dom": "^5.16.5",
-    "@testing-library/react": "^12.1.4",
-    "@types/jest": "^29.5.0",
-    "@types/lodash": "^4.14.194",
-    "@types/node": "^18.15.11",
-    "copy-webpack-plugin": "^11.0.0",
-    "css-loader": "^6.7.3",
-    "eslint-webpack-plugin": "^4.0.1",
-    "fork-ts-checker-webpack-plugin": "^8.0.0",
-    "glob": "^10.1.0",
-    "identity-obj-proxy": "3.0.0",
-    "jest": "^29.5.0",
-    "jest-environment-jsdom": "^29.5.0",
-    "prettier": "^2.8.7",
-    "replace-in-file-webpack-plugin": "^1.0.6",
-    "sass": "1.62.1",
-    "sass-loader": "13.2.2",
-    "style-loader": "3.3.2",
-    "swc-loader": "^0.2.3",
-    "ts-node": "^10.9.1",
-    "tsconfig-paths": "^4.2.0",
-    "typescript": "4.8.4",
-    "webpack": "^5.79.0",
-    "webpack-cli": "^5.0.1",
-    "webpack-livereload-plugin": "^3.0.2"
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "dependencies": {
-    "@emotion/css": "^11.1.3",
-    "@grafana/data": "^10.0.2",
-    "@grafana/runtime": "^10.0.2",
-    "@grafana/ui": "^10.0.2",
-    "react": "17.0.2",
-    "react-dom": "17.0.2",
-    "react-json-view": "^1.21.3",
-    "tslib": "2.5.0",
-    "web-component-load": "^1.0.1"
-  },
-  "packageManager": "npm@8.19.3"
+    "name": "qxip-flow-panel",
+    "version": "10.1.0",
+    "description": "Test plugin to lern dev enveroument",
+    "scripts": {
+        "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
+        "dev": "webpack -w -c ./.config/webpack/webpack.config.ts --env development",
+        "test": "jest --watch --onlyChanged",
+        "test:ci": "jest --passWithNoTests --maxWorkers 4",
+        "typecheck": "tsc --noEmit",
+        "lint": "eslint --cache --ignore-path ./.gitignore --ext .js,.jsx,.ts,.tsx .",
+        "lint:fix": "npm run lint -- --fix",
+        "e2e": "npm exec cypress install && npm exec grafana-e2e run",
+        "e2e:update": "npm exec cypress install && npm exec grafana-e2e run --update-screenshots",
+        "server": "docker-compose up --build",
+        "sign": "npx --yes @grafana/sign-plugin@latest"
+    },
+    "author": "Qxip",
+    "license": "AGPLv3",
+    "devDependencies": {
+        "@babel/core": "^7.21.4",
+        "@grafana/e2e": "^10.0.2",
+        "@grafana/e2e-selectors": "^10.0.2",
+        "@grafana/eslint-config": "^6.0.0",
+        "@grafana/tsconfig": "^1.3.0-rc1",
+        "@swc/core": "^1.3.51",
+        "@swc/helpers": "^0.5.0",
+        "@swc/jest": "^0.2.26",
+        "@testing-library/jest-dom": "^5.16.5",
+        "@testing-library/react": "^12.1.4",
+        "@types/jest": "^29.5.0",
+        "@types/lodash": "^4.14.194",
+        "@types/luxon": "^3.4.2",
+        "@types/node": "^18.15.11",
+        "copy-webpack-plugin": "^11.0.0",
+        "css-loader": "^6.7.3",
+        "eslint-webpack-plugin": "^4.0.1",
+        "fork-ts-checker-webpack-plugin": "^8.0.0",
+        "glob": "^10.1.0",
+        "identity-obj-proxy": "3.0.0",
+        "jest": "^29.5.0",
+        "jest-environment-jsdom": "^29.5.0",
+        "prettier": "^2.8.7",
+        "replace-in-file-webpack-plugin": "^1.0.6",
+        "sass": "1.62.1",
+        "sass-loader": "13.2.2",
+        "style-loader": "3.3.2",
+        "swc-loader": "^0.2.3",
+        "ts-node": "^10.9.1",
+        "tsconfig-paths": "^4.2.0",
+        "typescript": "4.8.4",
+        "webpack": "^5.79.0",
+        "webpack-cli": "^5.0.1",
+        "webpack-livereload-plugin": "^3.0.2"
+    },
+    "engines": {
+        "node": ">=16"
+    },
+    "dependencies": {
+        "@emotion/css": "^11.1.3",
+        "@grafana/data": "^10.0.2",
+        "@grafana/runtime": "^10.0.2",
+        "@grafana/ui": "^10.0.2",
+        "buffer": "^6.0.3",
+        "luxon": "^3.4.4",
+        "pcap-generator": "^0.2.3",
+        "react": "17.0.2",
+        "react-dom": "17.0.2",
+        "react-json-view": "^1.21.3",
+        "tslib": "2.5.0",
+        "util": "^0.12.5",
+        "web-component-load": "^1.0.1"
+    },
+    "packageManager": "npm@8.19.3"
 }
diff --git a/src/components/SimplePanel.tsx b/src/components/SimplePanel.tsx
index 85732ff..2fe2a03 100644
--- a/src/components/SimplePanel.tsx
+++ b/src/components/SimplePanel.tsx
@@ -4,15 +4,25 @@ import { SimpleOptions } from 'types';
 import { css, cx } from '@emotion/css';
 import './../../ngx-flow/widget/ngx-flow.js';
 import ReactJson from 'react-json-view';
+import { DateTime } from "luxon";
+// @ts-ignore
+import packets from '../libs/packets.js';
+// @ts-ignore
+import { configure } from 'pcap-generator'
+import { Buffer } from 'buffer'
+const ip = packets.ipPacket
+const udp = packets.udpPacket
+const tcp = packets.tcpPacket
 
 import {
     Button,
     MultiSelect,
     Collapse,
-    // AsyncSelect,
     Modal,
     useStyles2,
-    useTheme2
+    useTheme2,
+    Dropdown,
+    Menu
 } from '@grafana/ui';
 
 
@@ -202,6 +212,9 @@ function formattingDataAndSortIt(data: any, sortType = 'none') {
 
 }
 
+
+
+
 export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: any) => {
     const [flowData, setFlowData] = React.useState({ actors: [], data: [] });
     const [modalIsOpen, setModalIsOpen] = React.useState(false);
@@ -211,13 +224,28 @@ export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: a
     const onModalClose = () => {
         setModalIsOpen(false);
     };
+    // Export .txt
     useEffect(() => {
         const handler = (e: any) => {
 
             const [serie]: any = (data as any)?.series || [];
             const fields = serie?.fields || [];
             const lineField = fields.find((i: any) => i.name === 'Line') ?? [];
-            const exportText = lineField?.values.join('\n');
+            const exportText = lineField?.values.map((i: string, index: number) => {
+                let dt = DateTime.fromMillis(fields[0]?.values[index]?.timestamp).toISO()
+                dt = dt?.replace('+', '000+') ?? '';
+                if (fields[0]?.values[index]?.type !== 'sip') {
+                    i = '';
+                }
+                let proto = 'proto:'
+                if (i.includes('UDP')) {
+                    proto += "UDP"
+                } else if (i.includes('TCP')) {
+                    proto += "TCP"
+                }
+                console.log(proto)
+                return `${proto} ${dt} ${fields[0]?.values[index]?.src_ip} ---> ${fields[0]?.values[index]?.dst_ip} \n\n${i}`
+            }).join('\n');
             // Create element with <a> tag
             const link = document.createElement("a");
 
@@ -228,25 +256,96 @@ export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: a
             link.href = URL.createObjectURL(file);
 
             // Add file name
-            link.download = "sample.txt";
-            console.log(link)
-            // Add click event to <a> tag to save file.
+            const date = new Date();
+            link.download = `${date.toUTCString()}.txt`;
             link.click();
-            URL.revokeObjectURL(link.href);
-            document.removeChild(link)
-            // console.log(exportText)
         }
         document.addEventListener('export-flow-as-text', handler);
         return () => {
             document.removeEventListener('export-flow-as-text', handler)
         }
     }, [data])
+    // Export .pcap
+    useEffect(() => {
+        const handler = (e: any) => {
+
+            const [serie]: any = (data as any)?.series || [];
+            const fields = serie?.fields || [];
+            const lineField = fields.find((i: any) => i.name === 'Line') ?? [];
+            const packets2 = lineField?.values.map((field: string, index: number) => {
+
+                const labels = fields[0]?.values[index]
+                let proto = ''
+                if (field.includes('UDP')) {
+                    proto += "UDP"
+                } else if (field.includes('TCP')) {
+                    proto += "TCP"
+                }
+                const fieldObj = {
+                    data: field,
+                    srcIp: labels.src_ip,
+                    dstIp: labels.dst_ip,
+                    srcPort: labels.src_port,
+                    dstPort: labels.dst_port,
+                    ts: fields[0]?.values[index]?.timestamp,
+                    proto: proto === 'UDP' ? 17 : 6,
+                    type: fields[0]?.values[index]?.type,
+                    trafficClass: 0,
+                    flowLabel: 0,
+                    nextHeader: proto === 'UDP' ? 17 : 6
+                }
+                const ipv4_regex = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}$/gm;
+
+                const packet_data = proto === 'UDP' ? udp.encode({
+                    sourcePort: fieldObj.srcPort,
+                    destinationPort: fieldObj.dstPort,
+                    data: Buffer.from(fieldObj.data)
+                }) : tcp.encode({
+                    sourcePort: fieldObj.srcPort,
+                    destinationPort: fieldObj.dstPort,
+                    data: Buffer.from(fieldObj.data)
+                })
+                let ip_packet = ip.encode({
+                    version: ipv4_regex.test(fieldObj.srcIp) ? 4 : 6,
+                    protocol: fieldObj.proto,
+                    sourceIp: fieldObj.srcIp,
+                    destinationIp: fieldObj.dstIp,
+                    data: packet_data,
+                    ttl: 112,
+                    nextHeader: fieldObj.nextHeader,
+                    trafficClass: fieldObj.trafficClass,
+                    flowLabel: fieldObj.flowLabel
+                })
+                return {
+                    timestamp: fieldObj.ts,
+                    buffer: ip_packet,
+                    type: fields[0]?.values[index]?.type
+                }
+            }).filter((packet: any) => packet.type === 'sip')
+            const generator = configure({ Buffer: Buffer })
+            const pcapFile = generator(packets2)
+            const blob = new Blob([pcapFile], { type: 'application/vnd.tcpdump.pcap' });
+            // // Create element with <a> tag
+            const link = document.createElement("a");
+
+            // Add file content in the object URL
+            link.href = URL.createObjectURL(blob);
+
+            // Add file name
+            const date = new Date();
+            link.download = `${date.toUTCString()}.pcap`;
+            link.click();
+
+        }
+        document.addEventListener('export-flow-as-pcap', handler);
+        return () => {
+            document.removeEventListener('export-flow-as-pcap', handler)
+        }
+    }, [data])
     const styles = useStyles2(getStyles);
     React.useEffect(() => {
         const [serie]: any = (data as any)?.series || [];
         const fields = serie?.fields || [];
-        console.log({ options })
-        console.log(serie)
         if (fields) {
             const [firsField]: any = fields;
             const sortData = formattingDataAndSortIt(fields, options.sortoption);
@@ -297,6 +396,28 @@ export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: a
     // console.log(useTheme2());
     const themeName: string = useTheme2().name;
     const flowDataJSON = JSON.stringify(flowData);
+    const menu = (
+        <Menu>
+            <Menu.Item
+                onClick={() => {
+                    document.dispatchEvent(new CustomEvent('export-flow-as-png'));
+                }}
+                label='Export flow as PNG'
+            ></Menu.Item>
+            <Menu.Item
+                onClick={() => {
+                    document.dispatchEvent(new CustomEvent('export-flow-as-json'));
+                }}
+                label='Export flow as JSON'
+            ></Menu.Item>
+            <Menu.Item
+                onClick={() => {
+                    document.dispatchEvent(new CustomEvent('export-flow-as-pcap'));
+                }}
+                label='Export flow as PCAP'
+            ></Menu.Item>
+        </Menu>
+    )
     return (
         <div
             className={cx(
@@ -304,9 +425,27 @@ export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: a
                 css`
           width: ${width}px;
           height: ${height}px;
+          position: relative;
         `
             )}
         >
+            {data?.request?.app === 'dashboard' && (
+                // <span >
+                <Dropdown overlay={menu}>
+
+                    <Button className={cx(
+                        css`
+              position: absolute;
+              top: 15px;
+              right: 15px;
+              border: 1px solid ${themeName === 'Dark' ? 'hsla(240, 18.6%, 83.1%, 0.12)' : 'hsla(210, 12.2%, 16.1%, 0.12)'};
+              border-radius: 2px;
+              background-color: ${themeName === 'Dark' ? 'hsla(0, 0%, 0%, 0.5)' : 'hsla(0, 0%, 100%, 0.5)'};
+              z-index: 2;
+            `)} icon="bars" fill="text" variant="secondary" />
+                </Dropdown>
+                // </span>/
+            )}
             {/* <pre>{JSON.stringify(flowData)}</pre> */}
             {/* <FlowMemo flowData={flowData} themeName={themeName} /> */}
             <ngx-flow-out data-flow={flowDataJSON} theme={themeName} />
diff --git a/src/libs/packets.js b/src/libs/packets.js
new file mode 100644
index 0000000..cdbf374
--- /dev/null
+++ b/src/libs/packets.js
@@ -0,0 +1,2267 @@
+(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.packets = f() } })(function () {
+    var define, module, exports; return (function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { var c = "function" == typeof require && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
+        1: [function (require, module, exports) {
+            'use strict'
+
+            exports.byteLength = byteLength
+            exports.toByteArray = toByteArray
+            exports.fromByteArray = fromByteArray
+
+            var lookup = []
+            var revLookup = []
+            var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+
+            var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+            for (var i = 0, len = code.length; i < len; ++i) {
+                lookup[i] = code[i]
+                revLookup[code.charCodeAt(i)] = i
+            }
+
+            // Support decoding URL-safe base64 strings, as Node.js does.
+            // See: https://en.wikipedia.org/wiki/Base64#URL_applications
+            revLookup['-'.charCodeAt(0)] = 62
+            revLookup['_'.charCodeAt(0)] = 63
+
+            function getLens(b64) {
+                var len = b64.length
+
+                if (len % 4 > 0) {
+                    throw new Error('Invalid string. Length must be a multiple of 4')
+                }
+
+                // Trim off extra bytes after placeholder bytes are found
+                // See: https://github.com/beatgammit/base64-js/issues/42
+                var validLen = b64.indexOf('=')
+                if (validLen === -1) validLen = len
+
+                var placeHoldersLen = validLen === len
+                    ? 0
+                    : 4 - (validLen % 4)
+
+                return [validLen, placeHoldersLen]
+            }
+
+            // base64 is 4/3 + up to two characters of the original data
+            function byteLength(b64) {
+                var lens = getLens(b64)
+                var validLen = lens[0]
+                var placeHoldersLen = lens[1]
+                return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+            }
+
+            function _byteLength(b64, validLen, placeHoldersLen) {
+                return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
+            }
+
+            function toByteArray(b64) {
+                var tmp
+                var lens = getLens(b64)
+                var validLen = lens[0]
+                var placeHoldersLen = lens[1]
+
+                var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+
+                var curByte = 0
+
+                // if there are placeholders, only get up to the last complete 4 chars
+                var len = placeHoldersLen > 0
+                    ? validLen - 4
+                    : validLen
+
+                var i
+                for (i = 0; i < len; i += 4) {
+                    tmp =
+                        (revLookup[b64.charCodeAt(i)] << 18) |
+                        (revLookup[b64.charCodeAt(i + 1)] << 12) |
+                        (revLookup[b64.charCodeAt(i + 2)] << 6) |
+                        revLookup[b64.charCodeAt(i + 3)]
+                    arr[curByte++] = (tmp >> 16) & 0xFF
+                    arr[curByte++] = (tmp >> 8) & 0xFF
+                    arr[curByte++] = tmp & 0xFF
+                }
+
+                if (placeHoldersLen === 2) {
+                    tmp =
+                        (revLookup[b64.charCodeAt(i)] << 2) |
+                        (revLookup[b64.charCodeAt(i + 1)] >> 4)
+                    arr[curByte++] = tmp & 0xFF
+                }
+
+                if (placeHoldersLen === 1) {
+                    tmp =
+                        (revLookup[b64.charCodeAt(i)] << 10) |
+                        (revLookup[b64.charCodeAt(i + 1)] << 4) |
+                        (revLookup[b64.charCodeAt(i + 2)] >> 2)
+                    arr[curByte++] = (tmp >> 8) & 0xFF
+                    arr[curByte++] = tmp & 0xFF
+                }
+
+                return arr
+            }
+
+            function tripletToBase64(num) {
+                return lookup[num >> 18 & 0x3F] +
+                    lookup[num >> 12 & 0x3F] +
+                    lookup[num >> 6 & 0x3F] +
+                    lookup[num & 0x3F]
+            }
+
+            function encodeChunk(uint8, start, end) {
+                var tmp
+                var output = []
+                for (var i = start; i < end; i += 3) {
+                    tmp =
+                        ((uint8[i] << 16) & 0xFF0000) +
+                        ((uint8[i + 1] << 8) & 0xFF00) +
+                        (uint8[i + 2] & 0xFF)
+                    output.push(tripletToBase64(tmp))
+                }
+                return output.join('')
+            }
+
+            function fromByteArray(uint8) {
+                var tmp
+                var len = uint8.length
+                var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+                var parts = []
+                var maxChunkLength = 16383 // must be multiple of 3
+
+                // go through the array every three bytes, we'll deal with trailing stuff later
+                for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+                    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
+                }
+
+                // pad the end with zeros, but make sure to not forget the extra bytes
+                if (extraBytes === 1) {
+                    tmp = uint8[len - 1]
+                    parts.push(
+                        lookup[tmp >> 2] +
+                        lookup[(tmp << 4) & 0x3F] +
+                        '=='
+                    )
+                } else if (extraBytes === 2) {
+                    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
+                    parts.push(
+                        lookup[tmp >> 10] +
+                        lookup[(tmp >> 4) & 0x3F] +
+                        lookup[(tmp << 2) & 0x3F] +
+                        '='
+                    )
+                }
+
+                return parts.join('')
+            }
+
+        }, {}], 2: [function (require, module, exports) {
+            (function (Buffer) {
+                (function () {
+                    /*!
+                     * The buffer module from node.js, for the browser.
+                     *
+                     * @author   Feross Aboukhadijeh <https://feross.org>
+                     * @license  MIT
+                     */
+                    /* eslint-disable no-proto */
+
+                    'use strict'
+
+                    var base64 = require('base64-js')
+                    var ieee754 = require('ieee754')
+
+                    exports.Buffer = Buffer
+                    exports.SlowBuffer = SlowBuffer
+                    exports.INSPECT_MAX_BYTES = 50
+
+                    var K_MAX_LENGTH = 0x7fffffff
+                    exports.kMaxLength = K_MAX_LENGTH
+
+                    /**
+                     * If `Buffer.TYPED_ARRAY_SUPPORT`:
+                     *   === true    Use Uint8Array implementation (fastest)
+                     *   === false   Print warning and recommend using `buffer` v4.x which has an Object
+                     *               implementation (most compatible, even IE6)
+                     *
+                     * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
+                     * Opera 11.6+, iOS 4.2+.
+                     *
+                     * We report that the browser does not support typed arrays if the are not subclassable
+                     * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
+                     * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
+                     * for __proto__ and has a buggy typed array implementation.
+                     */
+                    Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
+
+                    if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
+                        typeof console.error === 'function') {
+                        console.error(
+                            'This browser lacks typed array (Uint8Array) support which is required by ' +
+                            '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
+                        )
+                    }
+
+                    function typedArraySupport() {
+                        // Can typed array instances can be augmented?
+                        try {
+                            var arr = new Uint8Array(1)
+                            arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
+                            return arr.foo() === 42
+                        } catch (e) {
+                            return false
+                        }
+                    }
+
+                    Object.defineProperty(Buffer.prototype, 'parent', {
+                        enumerable: true,
+                        get: function () {
+                            if (!Buffer.isBuffer(this)) return undefined
+                            return this.buffer
+                        }
+                    })
+
+                    Object.defineProperty(Buffer.prototype, 'offset', {
+                        enumerable: true,
+                        get: function () {
+                            if (!Buffer.isBuffer(this)) return undefined
+                            return this.byteOffset
+                        }
+                    })
+
+                    function createBuffer(length) {
+                        if (length > K_MAX_LENGTH) {
+                            throw new RangeError('The value "' + length + '" is invalid for option "size"')
+                        }
+                        // Return an augmented `Uint8Array` instance
+                        var buf = new Uint8Array(length)
+                        buf.__proto__ = Buffer.prototype
+                        return buf
+                    }
+
+                    /**
+                     * The Buffer constructor returns instances of `Uint8Array` that have their
+                     * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
+                     * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
+                     * and the `Uint8Array` methods. Square bracket notation works as expected -- it
+                     * returns a single octet.
+                     *
+                     * The `Uint8Array` prototype remains unmodified.
+                     */
+
+                    function Buffer(arg, encodingOrOffset, length) {
+                        // Common case.
+                        if (typeof arg === 'number') {
+                            if (typeof encodingOrOffset === 'string') {
+                                throw new TypeError(
+                                    'The "string" argument must be of type string. Received type number'
+                                )
+                            }
+                            return allocUnsafe(arg)
+                        }
+                        return from(arg, encodingOrOffset, length)
+                    }
+
+                    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
+                    if (typeof Symbol !== 'undefined' && Symbol.species != null &&
+                        Buffer[Symbol.species] === Buffer) {
+                        Object.defineProperty(Buffer, Symbol.species, {
+                            value: null,
+                            configurable: true,
+                            enumerable: false,
+                            writable: false
+                        })
+                    }
+
+                    Buffer.poolSize = 8192 // not used by this implementation
+
+                    function from(value, encodingOrOffset, length) {
+                        if (typeof value === 'string') {
+                            return fromString(value, encodingOrOffset)
+                        }
+
+                        if (ArrayBuffer.isView(value)) {
+                            return fromArrayLike(value)
+                        }
+
+                        if (value == null) {
+                            throw TypeError(
+                                'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+                                'or Array-like Object. Received type ' + (typeof value)
+                            )
+                        }
+
+                        if (isInstance(value, ArrayBuffer) ||
+                            (value && isInstance(value.buffer, ArrayBuffer))) {
+                            return fromArrayBuffer(value, encodingOrOffset, length)
+                        }
+
+                        if (typeof value === 'number') {
+                            throw new TypeError(
+                                'The "value" argument must not be of type number. Received type number'
+                            )
+                        }
+
+                        var valueOf = value.valueOf && value.valueOf()
+                        if (valueOf != null && valueOf !== value) {
+                            return Buffer.from(valueOf, encodingOrOffset, length)
+                        }
+
+                        var b = fromObject(value)
+                        if (b) return b
+
+                        if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
+                            typeof value[Symbol.toPrimitive] === 'function') {
+                            return Buffer.from(
+                                value[Symbol.toPrimitive]('string'), encodingOrOffset, length
+                            )
+                        }
+
+                        throw new TypeError(
+                            'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
+                            'or Array-like Object. Received type ' + (typeof value)
+                        )
+                    }
+
+                    /**
+                     * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
+                     * if value is a number.
+                     * Buffer.from(str[, encoding])
+                     * Buffer.from(array)
+                     * Buffer.from(buffer)
+                     * Buffer.from(arrayBuffer[, byteOffset[, length]])
+                     **/
+                    Buffer.from = function (value, encodingOrOffset, length) {
+                        return from(value, encodingOrOffset, length)
+                    }
+
+                    // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
+                    // https://github.com/feross/buffer/pull/148
+                    Buffer.prototype.__proto__ = Uint8Array.prototype
+                    Buffer.__proto__ = Uint8Array
+
+                    function assertSize(size) {
+                        if (typeof size !== 'number') {
+                            throw new TypeError('"size" argument must be of type number')
+                        } else if (size < 0) {
+                            throw new RangeError('The value "' + size + '" is invalid for option "size"')
+                        }
+                    }
+
+                    function alloc(size, fill, encoding) {
+                        assertSize(size)
+                        if (size <= 0) {
+                            return createBuffer(size)
+                        }
+                        if (fill !== undefined) {
+                            // Only pay attention to encoding if it's a string. This
+                            // prevents accidentally sending in a number that would
+                            // be interpretted as a start offset.
+                            return typeof encoding === 'string'
+                                ? createBuffer(size).fill(fill, encoding)
+                                : createBuffer(size).fill(fill)
+                        }
+                        return createBuffer(size)
+                    }
+
+                    /**
+                     * Creates a new filled Buffer instance.
+                     * alloc(size[, fill[, encoding]])
+                     **/
+                    Buffer.alloc = function (size, fill, encoding) {
+                        return alloc(size, fill, encoding)
+                    }
+
+                    function allocUnsafe(size) {
+                        assertSize(size)
+                        return createBuffer(size < 0 ? 0 : checked(size) | 0)
+                    }
+
+                    /**
+                     * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
+                     * */
+                    Buffer.allocUnsafe = function (size) {
+                        return allocUnsafe(size)
+                    }
+                    /**
+                     * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
+                     */
+                    Buffer.allocUnsafeSlow = function (size) {
+                        return allocUnsafe(size)
+                    }
+
+                    function fromString(string, encoding) {
+                        if (typeof encoding !== 'string' || encoding === '') {
+                            encoding = 'utf8'
+                        }
+
+                        if (!Buffer.isEncoding(encoding)) {
+                            throw new TypeError('Unknown encoding: ' + encoding)
+                        }
+
+                        var length = byteLength(string, encoding) | 0
+                        var buf = createBuffer(length)
+
+                        var actual = buf.write(string, encoding)
+
+                        if (actual !== length) {
+                            // Writing a hex string, for example, that contains invalid characters will
+                            // cause everything after the first invalid character to be ignored. (e.g.
+                            // 'abxxcd' will be treated as 'ab')
+                            buf = buf.slice(0, actual)
+                        }
+
+                        return buf
+                    }
+
+                    function fromArrayLike(array) {
+                        var length = array.length < 0 ? 0 : checked(array.length) | 0
+                        var buf = createBuffer(length)
+                        for (var i = 0; i < length; i += 1) {
+                            buf[i] = array[i] & 255
+                        }
+                        return buf
+                    }
+
+                    function fromArrayBuffer(array, byteOffset, length) {
+                        if (byteOffset < 0 || array.byteLength < byteOffset) {
+                            throw new RangeError('"offset" is outside of buffer bounds')
+                        }
+
+                        if (array.byteLength < byteOffset + (length || 0)) {
+                            throw new RangeError('"length" is outside of buffer bounds')
+                        }
+
+                        var buf
+                        if (byteOffset === undefined && length === undefined) {
+                            buf = new Uint8Array(array)
+                        } else if (length === undefined) {
+                            buf = new Uint8Array(array, byteOffset)
+                        } else {
+                            buf = new Uint8Array(array, byteOffset, length)
+                        }
+
+                        // Return an augmented `Uint8Array` instance
+                        buf.__proto__ = Buffer.prototype
+                        return buf
+                    }
+
+                    function fromObject(obj) {
+                        if (Buffer.isBuffer(obj)) {
+                            var len = checked(obj.length) | 0
+                            var buf = createBuffer(len)
+
+                            if (buf.length === 0) {
+                                return buf
+                            }
+
+                            obj.copy(buf, 0, 0, len)
+                            return buf
+                        }
+
+                        if (obj.length !== undefined) {
+                            if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
+                                return createBuffer(0)
+                            }
+                            return fromArrayLike(obj)
+                        }
+
+                        if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
+                            return fromArrayLike(obj.data)
+                        }
+                    }
+
+                    function checked(length) {
+                        // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
+                        // length is NaN (which is otherwise coerced to zero.)
+                        if (length >= K_MAX_LENGTH) {
+                            throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
+                                'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
+                        }
+                        return length | 0
+                    }
+
+                    function SlowBuffer(length) {
+                        if (+length != length) { // eslint-disable-line eqeqeq
+                            length = 0
+                        }
+                        return Buffer.alloc(+length)
+                    }
+
+                    Buffer.isBuffer = function isBuffer(b) {
+                        return b != null && b._isBuffer === true &&
+                            b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
+                    }
+
+                    Buffer.compare = function compare(a, b) {
+                        if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
+                        if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+                        if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
+                            throw new TypeError(
+                                'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+                            )
+                        }
+
+                        if (a === b) return 0
+
+                        var x = a.length
+                        var y = b.length
+
+                        for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+                            if (a[i] !== b[i]) {
+                                x = a[i]
+                                y = b[i]
+                                break
+                            }
+                        }
+
+                        if (x < y) return -1
+                        if (y < x) return 1
+                        return 0
+                    }
+
+                    Buffer.isEncoding = function isEncoding(encoding) {
+                        switch (String(encoding).toLowerCase()) {
+                            case 'hex':
+                            case 'utf8':
+                            case 'utf-8':
+                            case 'ascii':
+                            case 'latin1':
+                            case 'binary':
+                            case 'base64':
+                            case 'ucs2':
+                            case 'ucs-2':
+                            case 'utf16le':
+                            case 'utf-16le':
+                                return true
+                            default:
+                                return false
+                        }
+                    }
+
+                    Buffer.concat = function concat(list, length) {
+                        if (!Array.isArray(list)) {
+                            throw new TypeError('"list" argument must be an Array of Buffers')
+                        }
+
+                        if (list.length === 0) {
+                            return Buffer.alloc(0)
+                        }
+
+                        var i
+                        if (length === undefined) {
+                            length = 0
+                            for (i = 0; i < list.length; ++i) {
+                                length += list[i].length
+                            }
+                        }
+
+                        var buffer = Buffer.allocUnsafe(length)
+                        var pos = 0
+                        for (i = 0; i < list.length; ++i) {
+                            var buf = list[i]
+                            if (isInstance(buf, Uint8Array)) {
+                                buf = Buffer.from(buf)
+                            }
+                            if (!Buffer.isBuffer(buf)) {
+                                throw new TypeError('"list" argument must be an Array of Buffers')
+                            }
+                            buf.copy(buffer, pos)
+                            pos += buf.length
+                        }
+                        return buffer
+                    }
+
+                    function byteLength(string, encoding) {
+                        if (Buffer.isBuffer(string)) {
+                            return string.length
+                        }
+                        if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+                            return string.byteLength
+                        }
+                        if (typeof string !== 'string') {
+                            throw new TypeError(
+                                'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
+                                'Received type ' + typeof string
+                            )
+                        }
+
+                        var len = string.length
+                        var mustMatch = (arguments.length > 2 && arguments[2] === true)
+                        if (!mustMatch && len === 0) return 0
+
+                        // Use a for loop to avoid recursion
+                        var loweredCase = false
+                        for (; ;) {
+                            switch (encoding) {
+                                case 'ascii':
+                                case 'latin1':
+                                case 'binary':
+                                    return len
+                                case 'utf8':
+                                case 'utf-8':
+                                    return utf8ToBytes(string).length
+                                case 'ucs2':
+                                case 'ucs-2':
+                                case 'utf16le':
+                                case 'utf-16le':
+                                    return len * 2
+                                case 'hex':
+                                    return len >>> 1
+                                case 'base64':
+                                    return base64ToBytes(string).length
+                                default:
+                                    if (loweredCase) {
+                                        return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
+                                    }
+                                    encoding = ('' + encoding).toLowerCase()
+                                    loweredCase = true
+                            }
+                        }
+                    }
+                    Buffer.byteLength = byteLength
+
+                    function slowToString(encoding, start, end) {
+                        var loweredCase = false
+
+                        // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
+                        // property of a typed array.
+
+                        // This behaves neither like String nor Uint8Array in that we set start/end
+                        // to their upper/lower bounds if the value passed is out of range.
+                        // undefined is handled specially as per ECMA-262 6th Edition,
+                        // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
+                        if (start === undefined || start < 0) {
+                            start = 0
+                        }
+                        // Return early if start > this.length. Done here to prevent potential uint32
+                        // coercion fail below.
+                        if (start > this.length) {
+                            return ''
+                        }
+
+                        if (end === undefined || end > this.length) {
+                            end = this.length
+                        }
+
+                        if (end <= 0) {
+                            return ''
+                        }
+
+                        // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+                        end >>>= 0
+                        start >>>= 0
+
+                        if (end <= start) {
+                            return ''
+                        }
+
+                        if (!encoding) encoding = 'utf8'
+
+                        while (true) {
+                            switch (encoding) {
+                                case 'hex':
+                                    return hexSlice(this, start, end)
+
+                                case 'utf8':
+                                case 'utf-8':
+                                    return utf8Slice(this, start, end)
+
+                                case 'ascii':
+                                    return asciiSlice(this, start, end)
+
+                                case 'latin1':
+                                case 'binary':
+                                    return latin1Slice(this, start, end)
+
+                                case 'base64':
+                                    return base64Slice(this, start, end)
+
+                                case 'ucs2':
+                                case 'ucs-2':
+                                case 'utf16le':
+                                case 'utf-16le':
+                                    return utf16leSlice(this, start, end)
+
+                                default:
+                                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+                                    encoding = (encoding + '').toLowerCase()
+                                    loweredCase = true
+                            }
+                        }
+                    }
+
+                    // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
+                    // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
+                    // reliably in a browserify context because there could be multiple different
+                    // copies of the 'buffer' package in use. This method works even for Buffer
+                    // instances that were created from another copy of the `buffer` package.
+                    // See: https://github.com/feross/buffer/issues/154
+                    Buffer.prototype._isBuffer = true
+
+                    function swap(b, n, m) {
+                        var i = b[n]
+                        b[n] = b[m]
+                        b[m] = i
+                    }
+
+                    Buffer.prototype.swap16 = function swap16() {
+                        var len = this.length
+                        if (len % 2 !== 0) {
+                            throw new RangeError('Buffer size must be a multiple of 16-bits')
+                        }
+                        for (var i = 0; i < len; i += 2) {
+                            swap(this, i, i + 1)
+                        }
+                        return this
+                    }
+
+                    Buffer.prototype.swap32 = function swap32() {
+                        var len = this.length
+                        if (len % 4 !== 0) {
+                            throw new RangeError('Buffer size must be a multiple of 32-bits')
+                        }
+                        for (var i = 0; i < len; i += 4) {
+                            swap(this, i, i + 3)
+                            swap(this, i + 1, i + 2)
+                        }
+                        return this
+                    }
+
+                    Buffer.prototype.swap64 = function swap64() {
+                        var len = this.length
+                        if (len % 8 !== 0) {
+                            throw new RangeError('Buffer size must be a multiple of 64-bits')
+                        }
+                        for (var i = 0; i < len; i += 8) {
+                            swap(this, i, i + 7)
+                            swap(this, i + 1, i + 6)
+                            swap(this, i + 2, i + 5)
+                            swap(this, i + 3, i + 4)
+                        }
+                        return this
+                    }
+
+                    Buffer.prototype.toString = function toString() {
+                        var length = this.length
+                        if (length === 0) return ''
+                        if (arguments.length === 0) return utf8Slice(this, 0, length)
+                        return slowToString.apply(this, arguments)
+                    }
+
+                    Buffer.prototype.toLocaleString = Buffer.prototype.toString
+
+                    Buffer.prototype.equals = function equals(b) {
+                        if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
+                        if (this === b) return true
+                        return Buffer.compare(this, b) === 0
+                    }
+
+                    Buffer.prototype.inspect = function inspect() {
+                        var str = ''
+                        var max = exports.INSPECT_MAX_BYTES
+                        str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
+                        if (this.length > max) str += ' ... '
+                        return '<Buffer ' + str + '>'
+                    }
+
+                    Buffer.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+                        if (isInstance(target, Uint8Array)) {
+                            target = Buffer.from(target, target.offset, target.byteLength)
+                        }
+                        if (!Buffer.isBuffer(target)) {
+                            throw new TypeError(
+                                'The "target" argument must be one of type Buffer or Uint8Array. ' +
+                                'Received type ' + (typeof target)
+                            )
+                        }
+
+                        if (start === undefined) {
+                            start = 0
+                        }
+                        if (end === undefined) {
+                            end = target ? target.length : 0
+                        }
+                        if (thisStart === undefined) {
+                            thisStart = 0
+                        }
+                        if (thisEnd === undefined) {
+                            thisEnd = this.length
+                        }
+
+                        if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+                            throw new RangeError('out of range index')
+                        }
+
+                        if (thisStart >= thisEnd && start >= end) {
+                            return 0
+                        }
+                        if (thisStart >= thisEnd) {
+                            return -1
+                        }
+                        if (start >= end) {
+                            return 1
+                        }
+
+                        start >>>= 0
+                        end >>>= 0
+                        thisStart >>>= 0
+                        thisEnd >>>= 0
+
+                        if (this === target) return 0
+
+                        var x = thisEnd - thisStart
+                        var y = end - start
+                        var len = Math.min(x, y)
+
+                        var thisCopy = this.slice(thisStart, thisEnd)
+                        var targetCopy = target.slice(start, end)
+
+                        for (var i = 0; i < len; ++i) {
+                            if (thisCopy[i] !== targetCopy[i]) {
+                                x = thisCopy[i]
+                                y = targetCopy[i]
+                                break
+                            }
+                        }
+
+                        if (x < y) return -1
+                        if (y < x) return 1
+                        return 0
+                    }
+
+                    // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
+                    // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
+                    //
+                    // Arguments:
+                    // - buffer - a Buffer to search
+                    // - val - a string, Buffer, or number
+                    // - byteOffset - an index into `buffer`; will be clamped to an int32
+                    // - encoding - an optional encoding, relevant is val is a string
+                    // - dir - true for indexOf, false for lastIndexOf
+                    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+                        // Empty buffer means no match
+                        if (buffer.length === 0) return -1
+
+                        // Normalize byteOffset
+                        if (typeof byteOffset === 'string') {
+                            encoding = byteOffset
+                            byteOffset = 0
+                        } else if (byteOffset > 0x7fffffff) {
+                            byteOffset = 0x7fffffff
+                        } else if (byteOffset < -0x80000000) {
+                            byteOffset = -0x80000000
+                        }
+                        byteOffset = +byteOffset // Coerce to Number.
+                        if (numberIsNaN(byteOffset)) {
+                            // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
+                            byteOffset = dir ? 0 : (buffer.length - 1)
+                        }
+
+                        // Normalize byteOffset: negative offsets start from the end of the buffer
+                        if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+                        if (byteOffset >= buffer.length) {
+                            if (dir) return -1
+                            else byteOffset = buffer.length - 1
+                        } else if (byteOffset < 0) {
+                            if (dir) byteOffset = 0
+                            else return -1
+                        }
+
+                        // Normalize val
+                        if (typeof val === 'string') {
+                            val = Buffer.from(val, encoding)
+                        }
+
+                        // Finally, search either indexOf (if dir is true) or lastIndexOf
+                        if (Buffer.isBuffer(val)) {
+                            // Special case: looking for empty string/buffer always fails
+                            if (val.length === 0) {
+                                return -1
+                            }
+                            return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
+                        } else if (typeof val === 'number') {
+                            val = val & 0xFF // Search for a byte value [0-255]
+                            if (typeof Uint8Array.prototype.indexOf === 'function') {
+                                if (dir) {
+                                    return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
+                                } else {
+                                    return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
+                                }
+                            }
+                            return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)
+                        }
+
+                        throw new TypeError('val must be string, number or Buffer')
+                    }
+
+                    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+                        var indexSize = 1
+                        var arrLength = arr.length
+                        var valLength = val.length
+
+                        if (encoding !== undefined) {
+                            encoding = String(encoding).toLowerCase()
+                            if (encoding === 'ucs2' || encoding === 'ucs-2' ||
+                                encoding === 'utf16le' || encoding === 'utf-16le') {
+                                if (arr.length < 2 || val.length < 2) {
+                                    return -1
+                                }
+                                indexSize = 2
+                                arrLength /= 2
+                                valLength /= 2
+                                byteOffset /= 2
+                            }
+                        }
+
+                        function read(buf, i) {
+                            if (indexSize === 1) {
+                                return buf[i]
+                            } else {
+                                return buf.readUInt16BE(i * indexSize)
+                            }
+                        }
+
+                        var i
+                        if (dir) {
+                            var foundIndex = -1
+                            for (i = byteOffset; i < arrLength; i++) {
+                                if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+                                    if (foundIndex === -1) foundIndex = i
+                                    if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+                                } else {
+                                    if (foundIndex !== -1) i -= i - foundIndex
+                                    foundIndex = -1
+                                }
+                            }
+                        } else {
+                            if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+                            for (i = byteOffset; i >= 0; i--) {
+                                var found = true
+                                for (var j = 0; j < valLength; j++) {
+                                    if (read(arr, i + j) !== read(val, j)) {
+                                        found = false
+                                        break
+                                    }
+                                }
+                                if (found) return i
+                            }
+                        }
+
+                        return -1
+                    }
+
+                    Buffer.prototype.includes = function includes(val, byteOffset, encoding) {
+                        return this.indexOf(val, byteOffset, encoding) !== -1
+                    }
+
+                    Buffer.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+                        return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
+                    }
+
+                    Buffer.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+                        return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
+                    }
+
+                    function hexWrite(buf, string, offset, length) {
+                        offset = Number(offset) || 0
+                        var remaining = buf.length - offset
+                        if (!length) {
+                            length = remaining
+                        } else {
+                            length = Number(length)
+                            if (length > remaining) {
+                                length = remaining
+                            }
+                        }
+
+                        var strLen = string.length
+
+                        if (length > strLen / 2) {
+                            length = strLen / 2
+                        }
+                        for (var i = 0; i < length; ++i) {
+                            var parsed = parseInt(string.substr(i * 2, 2), 16)
+                            if (numberIsNaN(parsed)) return i
+                            buf[offset + i] = parsed
+                        }
+                        return i
+                    }
+
+                    function utf8Write(buf, string, offset, length) {
+                        return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
+                    }
+
+                    function asciiWrite(buf, string, offset, length) {
+                        return blitBuffer(asciiToBytes(string), buf, offset, length)
+                    }
+
+                    function latin1Write(buf, string, offset, length) {
+                        return asciiWrite(buf, string, offset, length)
+                    }
+
+                    function base64Write(buf, string, offset, length) {
+                        return blitBuffer(base64ToBytes(string), buf, offset, length)
+                    }
+
+                    function ucs2Write(buf, string, offset, length) {
+                        return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
+                    }
+
+                    Buffer.prototype.write = function write(string, offset, length, encoding) {
+                        // Buffer#write(string)
+                        if (offset === undefined) {
+                            encoding = 'utf8'
+                            length = this.length
+                            offset = 0
+                            // Buffer#write(string, encoding)
+                        } else if (length === undefined && typeof offset === 'string') {
+                            encoding = offset
+                            length = this.length
+                            offset = 0
+                            // Buffer#write(string, offset[, length][, encoding])
+                        } else if (isFinite(offset)) {
+                            offset = offset >>> 0
+                            if (isFinite(length)) {
+                                length = length >>> 0
+                                if (encoding === undefined) encoding = 'utf8'
+                            } else {
+                                encoding = length
+                                length = undefined
+                            }
+                        } else {
+                            throw new Error(
+                                'Buffer.write(string, encoding, offset[, length]) is no longer supported'
+                            )
+                        }
+
+                        var remaining = this.length - offset
+                        if (length === undefined || length > remaining) length = remaining
+
+                        if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
+                            throw new RangeError('Attempt to write outside buffer bounds')
+                        }
+
+                        if (!encoding) encoding = 'utf8'
+
+                        var loweredCase = false
+                        for (; ;) {
+                            switch (encoding) {
+                                case 'hex':
+                                    return hexWrite(this, string, offset, length)
+
+                                case 'utf8':
+                                case 'utf-8':
+                                    return utf8Write(this, string, offset, length)
+
+                                case 'ascii':
+                                    return asciiWrite(this, string, offset, length)
+
+                                case 'latin1':
+                                case 'binary':
+                                    return latin1Write(this, string, offset, length)
+
+                                case 'base64':
+                                    // Warning: maxLength not taken into account in base64Write
+                                    return base64Write(this, string, offset, length)
+
+                                case 'ucs2':
+                                case 'ucs-2':
+                                case 'utf16le':
+                                case 'utf-16le':
+                                    return ucs2Write(this, string, offset, length)
+
+                                default:
+                                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+                                    encoding = ('' + encoding).toLowerCase()
+                                    loweredCase = true
+                            }
+                        }
+                    }
+
+                    Buffer.prototype.toJSON = function toJSON() {
+                        return {
+                            type: 'Buffer',
+                            data: Array.prototype.slice.call(this._arr || this, 0)
+                        }
+                    }
+
+                    function base64Slice(buf, start, end) {
+                        if (start === 0 && end === buf.length) {
+                            return base64.fromByteArray(buf)
+                        } else {
+                            return base64.fromByteArray(buf.slice(start, end))
+                        }
+                    }
+
+                    function utf8Slice(buf, start, end) {
+                        end = Math.min(buf.length, end)
+                        var res = []
+
+                        var i = start
+                        while (i < end) {
+                            var firstByte = buf[i]
+                            var codePoint = null
+                            var bytesPerSequence = (firstByte > 0xEF) ? 4
+                                : (firstByte > 0xDF) ? 3
+                                    : (firstByte > 0xBF) ? 2
+                                        : 1
+
+                            if (i + bytesPerSequence <= end) {
+                                var secondByte, thirdByte, fourthByte, tempCodePoint
+
+                                switch (bytesPerSequence) {
+                                    case 1:
+                                        if (firstByte < 0x80) {
+                                            codePoint = firstByte
+                                        }
+                                        break
+                                    case 2:
+                                        secondByte = buf[i + 1]
+                                        if ((secondByte & 0xC0) === 0x80) {
+                                            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
+                                            if (tempCodePoint > 0x7F) {
+                                                codePoint = tempCodePoint
+                                            }
+                                        }
+                                        break
+                                    case 3:
+                                        secondByte = buf[i + 1]
+                                        thirdByte = buf[i + 2]
+                                        if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
+                                            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
+                                            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
+                                                codePoint = tempCodePoint
+                                            }
+                                        }
+                                        break
+                                    case 4:
+                                        secondByte = buf[i + 1]
+                                        thirdByte = buf[i + 2]
+                                        fourthByte = buf[i + 3]
+                                        if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
+                                            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
+                                            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
+                                                codePoint = tempCodePoint
+                                            }
+                                        }
+                                }
+                            }
+
+                            if (codePoint === null) {
+                                // we did not generate a valid codePoint so insert a
+                                // replacement char (U+FFFD) and advance only 1 byte
+                                codePoint = 0xFFFD
+                                bytesPerSequence = 1
+                            } else if (codePoint > 0xFFFF) {
+                                // encode to utf16 (surrogate pair dance)
+                                codePoint -= 0x10000
+                                res.push(codePoint >>> 10 & 0x3FF | 0xD800)
+                                codePoint = 0xDC00 | codePoint & 0x3FF
+                            }
+
+                            res.push(codePoint)
+                            i += bytesPerSequence
+                        }
+
+                        return decodeCodePointsArray(res)
+                    }
+
+                    // Based on http://stackoverflow.com/a/22747272/680742, the browser with
+                    // the lowest limit is Chrome, with 0x10000 args.
+                    // We go 1 magnitude less, for safety
+                    var MAX_ARGUMENTS_LENGTH = 0x1000
+
+                    function decodeCodePointsArray(codePoints) {
+                        var len = codePoints.length
+                        if (len <= MAX_ARGUMENTS_LENGTH) {
+                            return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
+                        }
+
+                        // Decode in chunks to avoid "call stack size exceeded".
+                        var res = ''
+                        var i = 0
+                        while (i < len) {
+                            res += String.fromCharCode.apply(
+                                String,
+                                codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+                            )
+                        }
+                        return res
+                    }
+
+                    function asciiSlice(buf, start, end) {
+                        var ret = ''
+                        end = Math.min(buf.length, end)
+
+                        for (var i = start; i < end; ++i) {
+                            ret += String.fromCharCode(buf[i] & 0x7F)
+                        }
+                        return ret
+                    }
+
+                    function latin1Slice(buf, start, end) {
+                        var ret = ''
+                        end = Math.min(buf.length, end)
+
+                        for (var i = start; i < end; ++i) {
+                            ret += String.fromCharCode(buf[i])
+                        }
+                        return ret
+                    }
+
+                    function hexSlice(buf, start, end) {
+                        var len = buf.length
+
+                        if (!start || start < 0) start = 0
+                        if (!end || end < 0 || end > len) end = len
+
+                        var out = ''
+                        for (var i = start; i < end; ++i) {
+                            out += toHex(buf[i])
+                        }
+                        return out
+                    }
+
+                    function utf16leSlice(buf, start, end) {
+                        var bytes = buf.slice(start, end)
+                        var res = ''
+                        for (var i = 0; i < bytes.length; i += 2) {
+                            res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
+                        }
+                        return res
+                    }
+
+                    Buffer.prototype.slice = function slice(start, end) {
+                        var len = this.length
+                        start = ~~start
+                        end = end === undefined ? len : ~~end
+
+                        if (start < 0) {
+                            start += len
+                            if (start < 0) start = 0
+                        } else if (start > len) {
+                            start = len
+                        }
+
+                        if (end < 0) {
+                            end += len
+                            if (end < 0) end = 0
+                        } else if (end > len) {
+                            end = len
+                        }
+
+                        if (end < start) end = start
+
+                        var newBuf = this.subarray(start, end)
+                        // Return an augmented `Uint8Array` instance
+                        newBuf.__proto__ = Buffer.prototype
+                        return newBuf
+                    }
+
+                    /*
+                     * Need to make sure that buffer isn't trying to write out of bounds.
+                     */
+                    function checkOffset(offset, ext, length) {
+                        if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
+                        if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+                    }
+
+                    Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+                        var val = this[offset]
+                        var mul = 1
+                        var i = 0
+                        while (++i < byteLength && (mul *= 0x100)) {
+                            val += this[offset + i] * mul
+                        }
+
+                        return val
+                    }
+
+                    Buffer.prototype.readUIntBE = function readUIntBE(offset, byteLength, noAssert) {
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) {
+                            checkOffset(offset, byteLength, this.length)
+                        }
+
+                        var val = this[offset + --byteLength]
+                        var mul = 1
+                        while (byteLength > 0 && (mul *= 0x100)) {
+                            val += this[offset + --byteLength] * mul
+                        }
+
+                        return val
+                    }
+
+                    Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 1, this.length)
+                        return this[offset]
+                    }
+
+                    Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        return this[offset] | (this[offset + 1] << 8)
+                    }
+
+                    Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        return (this[offset] << 8) | this[offset + 1]
+                    }
+
+                    Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+
+                        return ((this[offset]) |
+                            (this[offset + 1] << 8) |
+                            (this[offset + 2] << 16)) +
+                            (this[offset + 3] * 0x1000000)
+                    }
+
+                    Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+
+                        return (this[offset] * 0x1000000) +
+                            ((this[offset + 1] << 16) |
+                                (this[offset + 2] << 8) |
+                                this[offset + 3])
+                    }
+
+                    Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+                        var val = this[offset]
+                        var mul = 1
+                        var i = 0
+                        while (++i < byteLength && (mul *= 0x100)) {
+                            val += this[offset + i] * mul
+                        }
+                        mul *= 0x80
+
+                        if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+                        return val
+                    }
+
+                    Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+
+                        var i = byteLength
+                        var mul = 1
+                        var val = this[offset + --i]
+                        while (i > 0 && (mul *= 0x100)) {
+                            val += this[offset + --i] * mul
+                        }
+                        mul *= 0x80
+
+                        if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+
+                        return val
+                    }
+
+                    Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 1, this.length)
+                        if (!(this[offset] & 0x80)) return (this[offset])
+                        return ((0xff - this[offset] + 1) * -1)
+                    }
+
+                    Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        var val = this[offset] | (this[offset + 1] << 8)
+                        return (val & 0x8000) ? val | 0xFFFF0000 : val
+                    }
+
+                    Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        var val = this[offset + 1] | (this[offset] << 8)
+                        return (val & 0x8000) ? val | 0xFFFF0000 : val
+                    }
+
+                    Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+
+                        return (this[offset]) |
+                            (this[offset + 1] << 8) |
+                            (this[offset + 2] << 16) |
+                            (this[offset + 3] << 24)
+                    }
+
+                    Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+
+                        return (this[offset] << 24) |
+                            (this[offset + 1] << 16) |
+                            (this[offset + 2] << 8) |
+                            (this[offset + 3])
+                    }
+
+                    Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        return ieee754.read(this, offset, true, 23, 4)
+                    }
+
+                    Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        return ieee754.read(this, offset, false, 23, 4)
+                    }
+
+                    Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 8, this.length)
+                        return ieee754.read(this, offset, true, 52, 8)
+                    }
+
+                    Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+                        offset = offset >>> 0
+                        if (!noAssert) checkOffset(offset, 8, this.length)
+                        return ieee754.read(this, offset, false, 52, 8)
+                    }
+
+                    function checkInt(buf, value, offset, ext, max, min) {
+                        if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
+                        if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
+                        if (offset + ext > buf.length) throw new RangeError('Index out of range')
+                    }
+
+                    Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) {
+                            var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                            checkInt(this, value, offset, byteLength, maxBytes, 0)
+                        }
+
+                        var mul = 1
+                        var i = 0
+                        this[offset] = value & 0xFF
+                        while (++i < byteLength && (mul *= 0x100)) {
+                            this[offset + i] = (value / mul) & 0xFF
+                        }
+
+                        return offset + byteLength
+                    }
+
+                    Buffer.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        byteLength = byteLength >>> 0
+                        if (!noAssert) {
+                            var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                            checkInt(this, value, offset, byteLength, maxBytes, 0)
+                        }
+
+                        var i = byteLength - 1
+                        var mul = 1
+                        this[offset + i] = value & 0xFF
+                        while (--i >= 0 && (mul *= 0x100)) {
+                            this[offset + i] = (value / mul) & 0xFF
+                        }
+
+                        return offset + byteLength
+                    }
+
+                    Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+                        this[offset] = (value & 0xff)
+                        return offset + 1
+                    }
+
+                    Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+                        this[offset] = (value & 0xff)
+                        this[offset + 1] = (value >>> 8)
+                        return offset + 2
+                    }
+
+                    Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+                        this[offset] = (value >>> 8)
+                        this[offset + 1] = (value & 0xff)
+                        return offset + 2
+                    }
+
+                    Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+                        this[offset + 3] = (value >>> 24)
+                        this[offset + 2] = (value >>> 16)
+                        this[offset + 1] = (value >>> 8)
+                        this[offset] = (value & 0xff)
+                        return offset + 4
+                    }
+
+                    Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+                        this[offset] = (value >>> 24)
+                        this[offset + 1] = (value >>> 16)
+                        this[offset + 2] = (value >>> 8)
+                        this[offset + 3] = (value & 0xff)
+                        return offset + 4
+                    }
+
+                    Buffer.prototype.writeIntLE = function writeIntLE(value, offset, byteLength, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) {
+                            var limit = Math.pow(2, (8 * byteLength) - 1)
+
+                            checkInt(this, value, offset, byteLength, limit - 1, -limit)
+                        }
+
+                        var i = 0
+                        var mul = 1
+                        var sub = 0
+                        this[offset] = value & 0xFF
+                        while (++i < byteLength && (mul *= 0x100)) {
+                            if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+                                sub = 1
+                            }
+                            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+                        }
+
+                        return offset + byteLength
+                    }
+
+                    Buffer.prototype.writeIntBE = function writeIntBE(value, offset, byteLength, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) {
+                            var limit = Math.pow(2, (8 * byteLength) - 1)
+
+                            checkInt(this, value, offset, byteLength, limit - 1, -limit)
+                        }
+
+                        var i = byteLength - 1
+                        var mul = 1
+                        var sub = 0
+                        this[offset + i] = value & 0xFF
+                        while (--i >= 0 && (mul *= 0x100)) {
+                            if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+                                sub = 1
+                            }
+                            this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
+                        }
+
+                        return offset + byteLength
+                    }
+
+                    Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
+                        if (value < 0) value = 0xff + value + 1
+                        this[offset] = (value & 0xff)
+                        return offset + 1
+                    }
+
+                    Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+                        this[offset] = (value & 0xff)
+                        this[offset + 1] = (value >>> 8)
+                        return offset + 2
+                    }
+
+                    Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+                        this[offset] = (value >>> 8)
+                        this[offset + 1] = (value & 0xff)
+                        return offset + 2
+                    }
+
+                    Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+                        this[offset] = (value & 0xff)
+                        this[offset + 1] = (value >>> 8)
+                        this[offset + 2] = (value >>> 16)
+                        this[offset + 3] = (value >>> 24)
+                        return offset + 4
+                    }
+
+                    Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+                        if (value < 0) value = 0xffffffff + value + 1
+                        this[offset] = (value >>> 24)
+                        this[offset + 1] = (value >>> 16)
+                        this[offset + 2] = (value >>> 8)
+                        this[offset + 3] = (value & 0xff)
+                        return offset + 4
+                    }
+
+                    function checkIEEE754(buf, value, offset, ext, max, min) {
+                        if (offset + ext > buf.length) throw new RangeError('Index out of range')
+                        if (offset < 0) throw new RangeError('Index out of range')
+                    }
+
+                    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) {
+                            checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
+                        }
+                        ieee754.write(buf, value, offset, littleEndian, 23, 4)
+                        return offset + 4
+                    }
+
+                    Buffer.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+                        return writeFloat(this, value, offset, true, noAssert)
+                    }
+
+                    Buffer.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+                        return writeFloat(this, value, offset, false, noAssert)
+                    }
+
+                    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+                        value = +value
+                        offset = offset >>> 0
+                        if (!noAssert) {
+                            checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
+                        }
+                        ieee754.write(buf, value, offset, littleEndian, 52, 8)
+                        return offset + 8
+                    }
+
+                    Buffer.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+                        return writeDouble(this, value, offset, true, noAssert)
+                    }
+
+                    Buffer.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+                        return writeDouble(this, value, offset, false, noAssert)
+                    }
+
+                    // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
+                    Buffer.prototype.copy = function copy(target, targetStart, start, end) {
+                        if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
+                        if (!start) start = 0
+                        if (!end && end !== 0) end = this.length
+                        if (targetStart >= target.length) targetStart = target.length
+                        if (!targetStart) targetStart = 0
+                        if (end > 0 && end < start) end = start
+
+                        // Copy 0 bytes; we're done
+                        if (end === start) return 0
+                        if (target.length === 0 || this.length === 0) return 0
+
+                        // Fatal error conditions
+                        if (targetStart < 0) {
+                            throw new RangeError('targetStart out of bounds')
+                        }
+                        if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
+                        if (end < 0) throw new RangeError('sourceEnd out of bounds')
+
+                        // Are we oob?
+                        if (end > this.length) end = this.length
+                        if (target.length - targetStart < end - start) {
+                            end = target.length - targetStart + start
+                        }
+
+                        var len = end - start
+
+                        if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
+                            // Use built-in when available, missing from IE11
+                            this.copyWithin(targetStart, start, end)
+                        } else if (this === target && start < targetStart && targetStart < end) {
+                            // descending copy from end
+                            for (var i = len - 1; i >= 0; --i) {
+                                target[i + targetStart] = this[i + start]
+                            }
+                        } else {
+                            Uint8Array.prototype.set.call(
+                                target,
+                                this.subarray(start, end),
+                                targetStart
+                            )
+                        }
+
+                        return len
+                    }
+
+                    // Usage:
+                    //    buffer.fill(number[, offset[, end]])
+                    //    buffer.fill(buffer[, offset[, end]])
+                    //    buffer.fill(string[, offset[, end]][, encoding])
+                    Buffer.prototype.fill = function fill(val, start, end, encoding) {
+                        // Handle string cases:
+                        if (typeof val === 'string') {
+                            if (typeof start === 'string') {
+                                encoding = start
+                                start = 0
+                                end = this.length
+                            } else if (typeof end === 'string') {
+                                encoding = end
+                                end = this.length
+                            }
+                            if (encoding !== undefined && typeof encoding !== 'string') {
+                                throw new TypeError('encoding must be a string')
+                            }
+                            if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
+                                throw new TypeError('Unknown encoding: ' + encoding)
+                            }
+                            if (val.length === 1) {
+                                var code = val.charCodeAt(0)
+                                if ((encoding === 'utf8' && code < 128) ||
+                                    encoding === 'latin1') {
+                                    // Fast path: If `val` fits into a single byte, use that numeric value.
+                                    val = code
+                                }
+                            }
+                        } else if (typeof val === 'number') {
+                            val = val & 255
+                        }
+
+                        // Invalid ranges are not set to a default, so can range check early.
+                        if (start < 0 || this.length < start || this.length < end) {
+                            throw new RangeError('Out of range index')
+                        }
+
+                        if (end <= start) {
+                            return this
+                        }
+
+                        start = start >>> 0
+                        end = end === undefined ? this.length : end >>> 0
+
+                        if (!val) val = 0
+
+                        var i
+                        if (typeof val === 'number') {
+                            for (i = start; i < end; ++i) {
+                                this[i] = val
+                            }
+                        } else {
+                            var bytes = Buffer.isBuffer(val)
+                                ? val
+                                : Buffer.from(val, encoding)
+                            var len = bytes.length
+                            if (len === 0) {
+                                throw new TypeError('The value "' + val +
+                                    '" is invalid for argument "value"')
+                            }
+                            for (i = 0; i < end - start; ++i) {
+                                this[i + start] = bytes[i % len]
+                            }
+                        }
+
+                        return this
+                    }
+
+                    // HELPER FUNCTIONS
+                    // ================
+
+                    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+
+                    function base64clean(str) {
+                        // Node takes equal signs as end of the Base64 encoding
+                        str = str.split('=')[0]
+                        // Node strips out invalid characters like \n and \t from the string, base64-js does not
+                        str = str.trim().replace(INVALID_BASE64_RE, '')
+                        // Node converts strings with length < 2 to ''
+                        if (str.length < 2) return ''
+                        // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
+                        while (str.length % 4 !== 0) {
+                            str = str + '='
+                        }
+                        return str
+                    }
+
+                    function toHex(n) {
+                        if (n < 16) return '0' + n.toString(16)
+                        return n.toString(16)
+                    }
+
+                    function utf8ToBytes(string, units) {
+                        units = units || Infinity
+                        var codePoint
+                        var length = string.length
+                        var leadSurrogate = null
+                        var bytes = []
+
+                        for (var i = 0; i < length; ++i) {
+                            codePoint = string.charCodeAt(i)
+
+                            // is surrogate component
+                            if (codePoint > 0xD7FF && codePoint < 0xE000) {
+                                // last char was a lead
+                                if (!leadSurrogate) {
+                                    // no lead yet
+                                    if (codePoint > 0xDBFF) {
+                                        // unexpected trail
+                                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                        continue
+                                    } else if (i + 1 === length) {
+                                        // unpaired lead
+                                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                        continue
+                                    }
+
+                                    // valid lead
+                                    leadSurrogate = codePoint
+
+                                    continue
+                                }
+
+                                // 2 leads in a row
+                                if (codePoint < 0xDC00) {
+                                    if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                    leadSurrogate = codePoint
+                                    continue
+                                }
+
+                                // valid surrogate pair
+                                codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
+                            } else if (leadSurrogate) {
+                                // valid bmp char, but last char was a lead
+                                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                            }
+
+                            leadSurrogate = null
+
+                            // encode utf8
+                            if (codePoint < 0x80) {
+                                if ((units -= 1) < 0) break
+                                bytes.push(codePoint)
+                            } else if (codePoint < 0x800) {
+                                if ((units -= 2) < 0) break
+                                bytes.push(
+                                    codePoint >> 0x6 | 0xC0,
+                                    codePoint & 0x3F | 0x80
+                                )
+                            } else if (codePoint < 0x10000) {
+                                if ((units -= 3) < 0) break
+                                bytes.push(
+                                    codePoint >> 0xC | 0xE0,
+                                    codePoint >> 0x6 & 0x3F | 0x80,
+                                    codePoint & 0x3F | 0x80
+                                )
+                            } else if (codePoint < 0x110000) {
+                                if ((units -= 4) < 0) break
+                                bytes.push(
+                                    codePoint >> 0x12 | 0xF0,
+                                    codePoint >> 0xC & 0x3F | 0x80,
+                                    codePoint >> 0x6 & 0x3F | 0x80,
+                                    codePoint & 0x3F | 0x80
+                                )
+                            } else {
+                                throw new Error('Invalid code point')
+                            }
+                        }
+
+                        return bytes
+                    }
+
+                    function asciiToBytes(str) {
+                        var byteArray = []
+                        for (var i = 0; i < str.length; ++i) {
+                            // Node's code seems to be doing this and not & 0x7F..
+                            byteArray.push(str.charCodeAt(i) & 0xFF)
+                        }
+                        return byteArray
+                    }
+
+                    function utf16leToBytes(str, units) {
+                        var c, hi, lo
+                        var byteArray = []
+                        for (var i = 0; i < str.length; ++i) {
+                            if ((units -= 2) < 0) break
+
+                            c = str.charCodeAt(i)
+                            hi = c >> 8
+                            lo = c % 256
+                            byteArray.push(lo)
+                            byteArray.push(hi)
+                        }
+
+                        return byteArray
+                    }
+
+                    function base64ToBytes(str) {
+                        return base64.toByteArray(base64clean(str))
+                    }
+
+                    function blitBuffer(src, dst, offset, length) {
+                        for (var i = 0; i < length; ++i) {
+                            if ((i + offset >= dst.length) || (i >= src.length)) break
+                            dst[i + offset] = src[i]
+                        }
+                        return i
+                    }
+
+                    // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
+                    // the `instanceof` check but they should be treated as of that type.
+                    // See: https://github.com/feross/buffer/issues/166
+                    function isInstance(obj, type) {
+                        return obj instanceof type ||
+                            (obj != null && obj.constructor != null && obj.constructor.name != null &&
+                                obj.constructor.name === type.name)
+                    }
+                    function numberIsNaN(obj) {
+                        // For IE11 support
+                        return obj !== obj // eslint-disable-line no-self-compare
+                    }
+
+                }).call(this)
+            }).call(this, require("buffer").Buffer)
+        }, { "base64-js": 1, "buffer": 2, "ieee754": 3 }], 3: [function (require, module, exports) {
+            /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+            exports.read = function (buffer, offset, isLE, mLen, nBytes) {
+                var e, m
+                var eLen = (nBytes * 8) - mLen - 1
+                var eMax = (1 << eLen) - 1
+                var eBias = eMax >> 1
+                var nBits = -7
+                var i = isLE ? (nBytes - 1) : 0
+                var d = isLE ? -1 : 1
+                var s = buffer[offset + i]
+
+                i += d
+
+                e = s & ((1 << (-nBits)) - 1)
+                s >>= (-nBits)
+                nBits += eLen
+                for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) { }
+
+                m = e & ((1 << (-nBits)) - 1)
+                e >>= (-nBits)
+                nBits += mLen
+                for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) { }
+
+                if (e === 0) {
+                    e = 1 - eBias
+                } else if (e === eMax) {
+                    return m ? NaN : ((s ? -1 : 1) * Infinity)
+                } else {
+                    m = m + Math.pow(2, mLen)
+                    e = e - eBias
+                }
+                return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
+            }
+
+            exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
+                var e, m, c
+                var eLen = (nBytes * 8) - mLen - 1
+                var eMax = (1 << eLen) - 1
+                var eBias = eMax >> 1
+                var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+                var i = isLE ? 0 : (nBytes - 1)
+                var d = isLE ? 1 : -1
+                var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+
+                value = Math.abs(value)
+
+                if (isNaN(value) || value === Infinity) {
+                    m = isNaN(value) ? 1 : 0
+                    e = eMax
+                } else {
+                    e = Math.floor(Math.log(value) / Math.LN2)
+                    if (value * (c = Math.pow(2, -e)) < 1) {
+                        e--
+                        c *= 2
+                    }
+                    if (e + eBias >= 1) {
+                        value += rt / c
+                    } else {
+                        value += rt * Math.pow(2, 1 - eBias)
+                    }
+                    if (value * c >= 2) {
+                        e++
+                        c /= 2
+                    }
+
+                    if (e + eBias >= eMax) {
+                        m = 0
+                        e = eMax
+                    } else if (e + eBias >= 1) {
+                        m = ((value * c) - 1) * Math.pow(2, mLen)
+                        e = e + eBias
+                    } else {
+                        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
+                        e = 0
+                    }
+                }
+
+                for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) { }
+
+                e = (e << mLen) | m
+                eLen += mLen
+                for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) { }
+
+                buffer[offset + i - d] |= s * 128
+            }
+
+        }, {}], 4: [function (require, module, exports) {
+            module.exports = {
+                'ipPacket': require('./ip-packet'),
+                'udpPacket': require('./udp-packet'),
+                'tcpPacket': require('./tcp-packet')
+            }
+        }, { "./ip-packet": 5, "./tcp-packet": 6, "./udp-packet": 7 }], 5: [function (require, module, exports) {
+            (function (Buffer) {
+                (function () {
+                    module.exports = configure({})
+
+                    function configure(opts) {
+                        function encode(packet, buf, offset) {
+                            if (!buf) buf = new Buffer(encodingLength(packet, packet.version === 4 ? 20 : 40))
+                            if (!offset) offset = 0
+                            if (packet.version === 4) {
+
+                                // IPv4 header
+                                buf[offset] = packet.version << 4 | (packet.ihl || 5)
+                                buf[offset + 1] = (packet.dscp || 0) << 2 | (packet.ecn || 0)
+                                buf.writeUInt16BE(20 + packet.data.length, offset + 2)
+                                buf.writeUInt16BE(packet.identification || 0, offset + 4)
+                                buf.writeUInt16BE((packet.flags || 0) << 13 | (packet.fragmentOffset || 0), offset + 6)
+                                buf[offset + 8] = packet.ttl || 0
+                                buf[offset + 9] = packet.protocol || 0
+                                buf.writeUInt16BE(0, offset + 10)
+                                encodeIp(packet.sourceIp, buf, offset + 12)
+                                encodeIp(packet.destinationIp, buf, offset + 16)
+                                buf.writeUInt16BE(checksum(buf, offset, offset + 20), offset + 10)
+                                packet.data.copy(buf, offset + 20)
+
+                                encode.bytes = 20 + packet.data.length
+                            } else {
+                                // IPv6 header
+                                buf.writeUInt32BE(packet.version << 28 | (packet.trafficClass << 20) | packet.flowLabel, offset);
+                                buf.writeUInt16BE(packet.data.length, offset + 4);
+                                buf[offset + 6] = packet.nextHeader;
+                                buf[offset + 7] = packet.hopLimit;
+                                const sourceIpBuffer = Buffer.from(packet.sourceIp);
+                                const destinationIpBuffer = Buffer.from(packet.destinationIp);
+
+                                sourceIpBuffer.copy(buf, offset + 8, 0, 16);
+                                destinationIpBuffer.copy(buf, offset + 24, 0, 16);
+
+                                // Here you would continue encoding any additional IPv6 header fields
+
+                                packet.data.copy(buf, offset + 40);
+
+                                encode.bytes = 40 + packet.data.length;
+                            }
+
+                            return buf
+                        }
+
+                        function decode(buf, offset) {
+                            if (!offset) offset = 0
+
+                            var version = buf[offset] >> 4
+                            if (version !== 4) throw new Error('Currently only IPv4 is supported')
+                            var ihl = buf[offset] & 15
+                            if (ihl > 5) throw new Error('Currently only IHL <= 5 is supported')
+                            var length = buf.readUInt16BE(offset + 2)
+                            var decodedChecksum = buf.readUInt16BE(offset + 10)
+                            var ignoreChecksum = opts.allowNullChecksum && decodedChecksum === 0
+
+                            if (!ignoreChecksum) {
+                                var sum = checksum(buf, offset, offset + 20)
+
+                                if (sum) throw new Error('Bad checksum (' + sum + ')')
+                            }
+
+                            decode.bytes = length
+                            return {
+                                version: version,
+                                ihl: ihl,
+                                dscp: buf[offset + 1] >> 2,
+                                ecn: buf[offset + 1] & 3,
+                                length: length,
+                                identification: buf.readUInt16BE(offset + 4),
+                                flags: buf[offset + 6] >> 5,
+                                fragmentOffset: buf.readUInt16BE(offset + 6) & 8191,
+                                ttl: buf[offset + 8],
+                                protocol: buf[offset + 9],
+                                checksum: decodedChecksum,
+                                sourceIp: decodeIp(buf, offset + 12),
+                                destinationIp: decodeIp(buf, offset + 16),
+                                data: buf.slice(offset + 20, offset + length)
+                            }
+                        }
+
+                        function encodingLength(packet, ipPacketSize) {
+                            return ipPacketSize + packet.data.length
+                        }
+
+                        encode.bytes = decode.bytes = 0
+
+                        return {
+                            configure: configure,
+                            encodingLength: encodingLength,
+                            encode: encode,
+                            decode: decode
+                        }
+                    }
+
+                    function encodeIp(addr, buf, offset) {
+                        for (var i = 0; i < 4; i++) {
+                            var oct = parseInt(addr, 10)
+                            buf[offset++] = oct
+                            addr = addr.slice(oct < 100 ? oct < 10 ? 2 : 3 : 4)
+                        }
+                    }
+
+                    function decodeIp(buf, offset) {
+                        return buf[offset] + '.' + buf[offset + 1] + '.' + buf[offset + 2] + '.' + buf[offset + 3]
+                    }
+
+                    function checksum(buf, offset, end) {
+                        var sum = 0
+                        for (; offset < end; offset += 2) sum += buf.readUInt16BE(offset)
+                        while (true) {
+                            var carry = sum >> 16
+                            if (!carry) break
+                            sum = (sum & 0xffff) + carry
+                        }
+                        return ~sum & 0xffff
+                    }
+
+                }).call(this)
+            }).call(this, require("buffer").Buffer)
+        }, { "buffer": 2 }], 6: [function (require, module, exports) {
+            (function (Buffer) {
+                (function () {
+                    exports.encode = encode
+                    exports.decode = decode
+
+                    function encode({ data, sourcePort, destinationPort, sequenceNumber = 0, acknowledgmentNumber = 0 }) {
+                        const dataLength = data ? data.length : 0
+                        const packet = Buffer.alloc(dataLength)
+                        packet.writeUInt16BE(sourcePort, 0)
+                        packet.writeUInt16BE(destinationPort, 2)
+                        packet.writeUInt32BE(sequenceNumber, 4)
+                        packet.writeUInt32BE(acknowledgmentNumber, 8)
+                        packet.writeUInt16BE(0x5000, 12)
+                        if (data) data.copy(packet, 20)
+                        return packet
+                    }
+
+                    function decode(buffer) {
+                        const sourcePort = buffer.readUInt16BE(0)
+                        const destinationPort = buffer.readUInt16BE(2)
+                        const sequenceNumber = buffer.readUInt32BE(4)
+                        const acknowledgmentNumber = buffer.readUInt32BE(8)
+                        const dataOffset = buffer[12] >> 4 & 15
+                        const reserved = buffer[12] >> 1 & 7
+                        const flags = buffer.readUInt16BE(12) & 0b111111111
+                        const ns = flags >> 8 & 1
+                        const cwr = flags >> 7 & 1
+                        const ece = flags >> 6 & 1
+                        const urg = flags >> 5 & 1
+                        const ack = flags >> 4 & 1
+                        const psh = flags >> 3 & 1
+                        const rst = flags >> 2 & 1
+                        const syn = flags >> 1 & 1
+                        const fin = flags & 1
+                        const windowSize = buffer.readUInt16BE(14)
+                        const checksum = buffer.readUInt16BE(16)
+                        const urgentPointer = buffer.readUInt16BE(18)
+                        const dataOffsetAsBytes = dataOffset * 4
+                        const data = buffer.slice(dataOffsetAsBytes, buffer.length)
+
+                        return {
+                            sourcePort, destinationPort, sequenceNumber, acknowledgmentNumber, dataOffset,
+                            flags, reserved, ns, cwr, ece, urg, ack, psh, rst, syn, fin,
+                            windowSize, checksum, urgentPointer, data
+                        }
+                    }
+                }).call(this)
+            }).call(this, require("buffer").Buffer)
+        }, { "buffer": 2 }], 7: [function (require, module, exports) {
+            (function (Buffer) {
+                (function () {
+                    exports.encode = function (packet) {
+                        var data = packet.data, len = data.length
+                        var srcport = packet.sourcePort, dstport = packet.destinationPort
+                        var buf = Buffer.alloc(len + 8)
+                        buf.writeUInt16BE(srcport, 0)
+                        buf.writeUInt16BE(dstport, 2)
+                        buf.writeUInt16BE(buf.length, 4)
+                        packet.data.copy(buf, 8)
+                        buf.writeUInt16BE(checksum(packet, buf), 6)
+                        return buf
+                    }
+
+                    exports.decode = function (buf) {
+                        var len = buf.readUInt16BE(4)
+                        return {
+                            sourcePort: buf.readUInt16BE(0),
+                            destinationPort: buf.readUInt16BE(2),
+                            length: len,
+                            checksum: buf.readUInt16BE(6),
+                            data: buf.slice(8, len)
+                        }
+                    }
+
+                    exports.checksum = checksum
+                    function checksum(packet, buf) {
+                        // pseudo header: srcip (16), dstip (16), 0 (8), proto (8), udp len (16)
+                        var len = buf.length
+                        var srcip = packet.sourceIp
+                        var dstip = packet.destinationIp
+                        if (!srcip || !dstip) return 0xffff
+                        var protocol = packet.protocol === undefined ? 0x11 : packet.protocol
+                        var sum = 0xffff
+                        // pseudo header: srcip (16), dstip (16), 0 (8), proto (8), udp len (16)
+                        if (srcip && dstip) {
+                            if (typeof srcip === 'string') srcip = Buffer.from(srcip.split('.'))
+                            if (typeof dstip === 'string') dstip = Buffer.from(dstip.split('.'))
+                            sum = 0
+                            var pad = len % 2
+                            for (var i = 0; i < len + pad; i += 2) {
+                                if (i === 6) continue // ignore the currently written checksum
+                                sum += ((buf[i] << 8) & 0xff00) + ((buf[i + 1]) & 0xff)
+                            }
+                            for (var i = 0; i < 4; i += 2) {
+                                sum += ((srcip[i] << 8) & 0xff00) + (srcip[i + 1] & 0xff)
+                            }
+                            for (var i = 0; i < 4; i += 2) {
+                                sum += ((dstip[i] << 8) & 0xff00) + (dstip[i + 1] & 0xff)
+                            }
+                            sum += protocol + len
+                            while (sum >> 16) {
+                                sum = (sum & 0xffff) + (sum >> 16)
+                            }
+                            sum = 0xffff ^ sum
+                        }
+                        return sum
+                    }
+
+                }).call(this)
+            }).call(this, require("buffer").Buffer)
+        }, { "buffer": 2 }]
+    }, {}, [4])(4)
+});

From a2330449ee62277c9827caa2c31d1a7a8f9896a9 Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Tue, 19 Mar 2024 11:19:44 +0200
Subject: [PATCH 4/8] fix: lint

---
 src/libs/packets.js | 618 ++++++++++++++++++++++----------------------
 1 file changed, 309 insertions(+), 309 deletions(-)

diff --git a/src/libs/packets.js b/src/libs/packets.js
index cdbf374..6f160cf 100644
--- a/src/libs/packets.js
+++ b/src/libs/packets.js
@@ -1,5 +1,5 @@
-(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { var g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.packets = f() } })(function () {
-    var define, module, exports; return (function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { var c = "function" == typeof require && require; if (!f && c) return c(i, !0); if (u) return u(i, !0); var a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } var p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { var n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (var u = "function" == typeof require && require, i = 0; i < t.length; i++)o(t[i]); return o } return r })()({
+(function (f) { if (typeof exports === "object" && typeof module !== "undefined") { module.exports = f() } else if (typeof define === "function" && define.amd) { define([], f) } else { let g; if (typeof window !== "undefined") { g = window } else if (typeof global !== "undefined") { g = global } else if (typeof self !== "undefined") { g = self } else { g = this } g.packets = f() } })(function () {
+    let define, module, exports; return (function () { function r(e, n, t) { function o(i, f) { if (!n[i]) { if (!e[i]) { let c = "function" === typeof require && require; if (!f && c) { return c(i, !0); } if (u) { return u(i, !0); } let a = new Error("Cannot find module '" + i + "'"); throw a.code = "MODULE_NOT_FOUND", a } let p = n[i] = { exports: {} }; e[i][0].call(p.exports, function (r) { let n = e[i][1][r]; return o(n || r) }, p, p.exports, r, e, n, t) } return n[i].exports } for (let u = "function" === typeof require && require, i = 0; i < t.length; i++) { o(t[i]); } return o } return r })()({
         1: [function (require, module, exports) {
             'use strict'
 
@@ -7,12 +7,12 @@
             exports.toByteArray = toByteArray
             exports.fromByteArray = fromByteArray
 
-            var lookup = []
-            var revLookup = []
-            var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
+            let lookup = []
+            let revLookup = []
+            let Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
 
-            var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
-            for (var i = 0, len = code.length; i < len; ++i) {
+            let code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+            for (let i = 0, len = code.length; i < len; ++i) {
                 lookup[i] = code[i]
                 revLookup[code.charCodeAt(i)] = i
             }
@@ -23,7 +23,7 @@
             revLookup['_'.charCodeAt(0)] = 63
 
             function getLens(b64) {
-                var len = b64.length
+                let len = b64.length
 
                 if (len % 4 > 0) {
                     throw new Error('Invalid string. Length must be a multiple of 4')
@@ -31,10 +31,10 @@
 
                 // Trim off extra bytes after placeholder bytes are found
                 // See: https://github.com/beatgammit/base64-js/issues/42
-                var validLen = b64.indexOf('=')
-                if (validLen === -1) validLen = len
+                let validLen = b64.indexOf('=')
+                if (validLen === -1) { validLen = len }
 
-                var placeHoldersLen = validLen === len
+                let placeHoldersLen = validLen === len
                     ? 0
                     : 4 - (validLen % 4)
 
@@ -43,9 +43,9 @@
 
             // base64 is 4/3 + up to two characters of the original data
             function byteLength(b64) {
-                var lens = getLens(b64)
-                var validLen = lens[0]
-                var placeHoldersLen = lens[1]
+                let lens = getLens(b64)
+                let validLen = lens[0]
+                let placeHoldersLen = lens[1]
                 return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
             }
 
@@ -54,21 +54,21 @@
             }
 
             function toByteArray(b64) {
-                var tmp
-                var lens = getLens(b64)
-                var validLen = lens[0]
-                var placeHoldersLen = lens[1]
+                let tmp
+                let lens = getLens(b64)
+                let validLen = lens[0]
+                let placeHoldersLen = lens[1]
 
-                var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
+                let arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
 
-                var curByte = 0
+                let curByte = 0
 
                 // if there are placeholders, only get up to the last complete 4 chars
-                var len = placeHoldersLen > 0
+                let len = placeHoldersLen > 0
                     ? validLen - 4
                     : validLen
 
-                var i
+                let i
                 for (i = 0; i < len; i += 4) {
                     tmp =
                         (revLookup[b64.charCodeAt(i)] << 18) |
@@ -107,9 +107,9 @@
             }
 
             function encodeChunk(uint8, start, end) {
-                var tmp
-                var output = []
-                for (var i = start; i < end; i += 3) {
+                let tmp
+                let output = []
+                for (let i = start; i < end; i += 3) {
                     tmp =
                         ((uint8[i] << 16) & 0xFF0000) +
                         ((uint8[i + 1] << 8) & 0xFF00) +
@@ -120,14 +120,14 @@
             }
 
             function fromByteArray(uint8) {
-                var tmp
-                var len = uint8.length
-                var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
-                var parts = []
-                var maxChunkLength = 16383 // must be multiple of 3
+                let tmp
+                let len = uint8.length
+                let extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
+                let parts = []
+                let maxChunkLength = 16383 // must be multiple of 3
 
                 // go through the array every three bytes, we'll deal with trailing stuff later
-                for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+                for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
                     parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
                 }
 
@@ -165,14 +165,14 @@
 
                     'use strict'
 
-                    var base64 = require('base64-js')
-                    var ieee754 = require('ieee754')
+                    let base64 = require('base64-js')
+                    let ieee754 = require('ieee754')
 
                     exports.Buffer = Buffer
                     exports.SlowBuffer = SlowBuffer
                     exports.INSPECT_MAX_BYTES = 50
 
-                    var K_MAX_LENGTH = 0x7fffffff
+                    let K_MAX_LENGTH = 0x7fffffff
                     exports.kMaxLength = K_MAX_LENGTH
 
                     /**
@@ -202,7 +202,7 @@
                     function typedArraySupport() {
                         // Can typed array instances can be augmented?
                         try {
-                            var arr = new Uint8Array(1)
+                            let arr = new Uint8Array(1)
                             arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
                             return arr.foo() === 42
                         } catch (e) {
@@ -213,7 +213,7 @@
                     Object.defineProperty(Buffer.prototype, 'parent', {
                         enumerable: true,
                         get: function () {
-                            if (!Buffer.isBuffer(this)) return undefined
+                            if (!Buffer.isBuffer(this)) { return undefined }
                             return this.buffer
                         }
                     })
@@ -221,7 +221,7 @@
                     Object.defineProperty(Buffer.prototype, 'offset', {
                         enumerable: true,
                         get: function () {
-                            if (!Buffer.isBuffer(this)) return undefined
+                            if (!Buffer.isBuffer(this)) { return undefined }
                             return this.byteOffset
                         }
                     })
@@ -231,7 +231,7 @@
                             throw new RangeError('The value "' + length + '" is invalid for option "size"')
                         }
                         // Return an augmented `Uint8Array` instance
-                        var buf = new Uint8Array(length)
+                        let buf = new Uint8Array(length)
                         buf.__proto__ = Buffer.prototype
                         return buf
                     }
@@ -299,13 +299,13 @@
                             )
                         }
 
-                        var valueOf = value.valueOf && value.valueOf()
+                        let valueOf = value.valueOf && value.valueOf()
                         if (valueOf != null && valueOf !== value) {
                             return Buffer.from(valueOf, encodingOrOffset, length)
                         }
 
-                        var b = fromObject(value)
-                        if (b) return b
+                        let b = fromObject(value)
+                        if (b) { return b }
 
                         if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
                             typeof value[Symbol.toPrimitive] === 'function') {
@@ -396,10 +396,10 @@
                             throw new TypeError('Unknown encoding: ' + encoding)
                         }
 
-                        var length = byteLength(string, encoding) | 0
-                        var buf = createBuffer(length)
+                        let length = byteLength(string, encoding) | 0
+                        let buf = createBuffer(length)
 
-                        var actual = buf.write(string, encoding)
+                        let actual = buf.write(string, encoding)
 
                         if (actual !== length) {
                             // Writing a hex string, for example, that contains invalid characters will
@@ -412,9 +412,9 @@
                     }
 
                     function fromArrayLike(array) {
-                        var length = array.length < 0 ? 0 : checked(array.length) | 0
-                        var buf = createBuffer(length)
-                        for (var i = 0; i < length; i += 1) {
+                        let length = array.length < 0 ? 0 : checked(array.length) | 0
+                        let buf = createBuffer(length)
+                        for (let i = 0; i < length; i += 1) {
                             buf[i] = array[i] & 255
                         }
                         return buf
@@ -429,7 +429,7 @@
                             throw new RangeError('"length" is outside of buffer bounds')
                         }
 
-                        var buf
+                        let buf
                         if (byteOffset === undefined && length === undefined) {
                             buf = new Uint8Array(array)
                         } else if (length === undefined) {
@@ -445,8 +445,8 @@
 
                     function fromObject(obj) {
                         if (Buffer.isBuffer(obj)) {
-                            var len = checked(obj.length) | 0
-                            var buf = createBuffer(len)
+                            let len = checked(obj.length) | 0
+                            let buf = createBuffer(len)
 
                             if (buf.length === 0) {
                                 return buf
@@ -491,20 +491,20 @@
                     }
 
                     Buffer.compare = function compare(a, b) {
-                        if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
-                        if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
+                        if (isInstance(a, Uint8Array)) { a = Buffer.from(a, a.offset, a.byteLength) }
+                        if (isInstance(b, Uint8Array)) { b = Buffer.from(b, b.offset, b.byteLength) }
                         if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
                             throw new TypeError(
                                 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
                             )
                         }
 
-                        if (a === b) return 0
+                        if (a === b) { return 0 }
 
-                        var x = a.length
-                        var y = b.length
+                        let x = a.length
+                        let y = b.length
 
-                        for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+                        for (let i = 0, len = Math.min(x, y); i < len; ++i) {
                             if (a[i] !== b[i]) {
                                 x = a[i]
                                 y = b[i]
@@ -512,8 +512,8 @@
                             }
                         }
 
-                        if (x < y) return -1
-                        if (y < x) return 1
+                        if (x < y) { return -1 }
+                        if (y < x) { return 1 }
                         return 0
                     }
 
@@ -545,7 +545,7 @@
                             return Buffer.alloc(0)
                         }
 
-                        var i
+                        let i
                         if (length === undefined) {
                             length = 0
                             for (i = 0; i < list.length; ++i) {
@@ -553,10 +553,10 @@
                             }
                         }
 
-                        var buffer = Buffer.allocUnsafe(length)
-                        var pos = 0
+                        let buffer = Buffer.allocUnsafe(length)
+                        let pos = 0
                         for (i = 0; i < list.length; ++i) {
-                            var buf = list[i]
+                            let buf = list[i]
                             if (isInstance(buf, Uint8Array)) {
                                 buf = Buffer.from(buf)
                             }
@@ -583,12 +583,12 @@
                             )
                         }
 
-                        var len = string.length
-                        var mustMatch = (arguments.length > 2 && arguments[2] === true)
-                        if (!mustMatch && len === 0) return 0
+                        let len = string.length
+                        let mustMatch = (arguments.length > 2 && arguments[2] === true)
+                        if (!mustMatch && len === 0) { return 0 }
 
                         // Use a for loop to avoid recursion
-                        var loweredCase = false
+                        let loweredCase = false
                         for (; ;) {
                             switch (encoding) {
                                 case 'ascii':
@@ -619,7 +619,7 @@
                     Buffer.byteLength = byteLength
 
                     function slowToString(encoding, start, end) {
-                        var loweredCase = false
+                        let loweredCase = false
 
                         // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
                         // property of a typed array.
@@ -653,7 +653,7 @@
                             return ''
                         }
 
-                        if (!encoding) encoding = 'utf8'
+                        if (!encoding) { encoding = 'utf8' }
 
                         while (true) {
                             switch (encoding) {
@@ -681,7 +681,7 @@
                                     return utf16leSlice(this, start, end)
 
                                 default:
-                                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+                                    if (loweredCase) { throw new TypeError('Unknown encoding: ' + encoding) }
                                     encoding = (encoding + '').toLowerCase()
                                     loweredCase = true
                             }
@@ -697,28 +697,28 @@
                     Buffer.prototype._isBuffer = true
 
                     function swap(b, n, m) {
-                        var i = b[n]
+                        let i = b[n]
                         b[n] = b[m]
                         b[m] = i
                     }
 
                     Buffer.prototype.swap16 = function swap16() {
-                        var len = this.length
+                        let len = this.length
                         if (len % 2 !== 0) {
                             throw new RangeError('Buffer size must be a multiple of 16-bits')
                         }
-                        for (var i = 0; i < len; i += 2) {
+                        for (let i = 0; i < len; i += 2) {
                             swap(this, i, i + 1)
                         }
                         return this
                     }
 
                     Buffer.prototype.swap32 = function swap32() {
-                        var len = this.length
+                        let len = this.length
                         if (len % 4 !== 0) {
                             throw new RangeError('Buffer size must be a multiple of 32-bits')
                         }
-                        for (var i = 0; i < len; i += 4) {
+                        for (let i = 0; i < len; i += 4) {
                             swap(this, i, i + 3)
                             swap(this, i + 1, i + 2)
                         }
@@ -726,11 +726,11 @@
                     }
 
                     Buffer.prototype.swap64 = function swap64() {
-                        var len = this.length
+                        let len = this.length
                         if (len % 8 !== 0) {
                             throw new RangeError('Buffer size must be a multiple of 64-bits')
                         }
-                        for (var i = 0; i < len; i += 8) {
+                        for (let i = 0; i < len; i += 8) {
                             swap(this, i, i + 7)
                             swap(this, i + 1, i + 6)
                             swap(this, i + 2, i + 5)
@@ -740,25 +740,25 @@
                     }
 
                     Buffer.prototype.toString = function toString() {
-                        var length = this.length
-                        if (length === 0) return ''
-                        if (arguments.length === 0) return utf8Slice(this, 0, length)
+                        let length = this.length
+                        if (length === 0) { return '' }
+                        if (arguments.length === 0) { return utf8Slice(this, 0, length) }
                         return slowToString.apply(this, arguments)
                     }
 
                     Buffer.prototype.toLocaleString = Buffer.prototype.toString
 
                     Buffer.prototype.equals = function equals(b) {
-                        if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
-                        if (this === b) return true
+                        if (!Buffer.isBuffer(b)) { throw new TypeError('Argument must be a Buffer') }
+                        if (this === b) { return true }
                         return Buffer.compare(this, b) === 0
                     }
 
                     Buffer.prototype.inspect = function inspect() {
-                        var str = ''
-                        var max = exports.INSPECT_MAX_BYTES
+                        let str = ''
+                        let max = exports.INSPECT_MAX_BYTES
                         str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
-                        if (this.length > max) str += ' ... '
+                        if (this.length > max) { str += ' ... ' }
                         return '<Buffer ' + str + '>'
                     }
 
@@ -805,16 +805,16 @@
                         thisStart >>>= 0
                         thisEnd >>>= 0
 
-                        if (this === target) return 0
+                        if (this === target) { return 0 }
 
-                        var x = thisEnd - thisStart
-                        var y = end - start
-                        var len = Math.min(x, y)
+                        let x = thisEnd - thisStart
+                        let y = end - start
+                        let len = Math.min(x, y)
 
-                        var thisCopy = this.slice(thisStart, thisEnd)
-                        var targetCopy = target.slice(start, end)
+                        let thisCopy = this.slice(thisStart, thisEnd)
+                        let targetCopy = target.slice(start, end)
 
-                        for (var i = 0; i < len; ++i) {
+                        for (let i = 0; i < len; ++i) {
                             if (thisCopy[i] !== targetCopy[i]) {
                                 x = thisCopy[i]
                                 y = targetCopy[i]
@@ -822,8 +822,8 @@
                             }
                         }
 
-                        if (x < y) return -1
-                        if (y < x) return 1
+                        if (x < y) { return -1 }
+                        if (y < x) { return 1 }
                         return 0
                     }
 
@@ -838,7 +838,7 @@
                     // - dir - true for indexOf, false for lastIndexOf
                     function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
                         // Empty buffer means no match
-                        if (buffer.length === 0) return -1
+                        if (buffer.length === 0) { return -1 }
 
                         // Normalize byteOffset
                         if (typeof byteOffset === 'string') {
@@ -856,13 +856,13 @@
                         }
 
                         // Normalize byteOffset: negative offsets start from the end of the buffer
-                        if (byteOffset < 0) byteOffset = buffer.length + byteOffset
+                        if (byteOffset < 0) { byteOffset = buffer.length + byteOffset }
                         if (byteOffset >= buffer.length) {
-                            if (dir) return -1
-                            else byteOffset = buffer.length - 1
+                            if (dir) { return -1 }
+                            else { byteOffset = buffer.length - 1 }
                         } else if (byteOffset < 0) {
-                            if (dir) byteOffset = 0
-                            else return -1
+                            if (dir) { byteOffset = 0 }
+                            else { return -1 }
                         }
 
                         // Normalize val
@@ -893,9 +893,9 @@
                     }
 
                     function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
-                        var indexSize = 1
-                        var arrLength = arr.length
-                        var valLength = val.length
+                        let indexSize = 1
+                        let arrLength = arr.length
+                        let valLength = val.length
 
                         if (encoding !== undefined) {
                             encoding = String(encoding).toLowerCase()
@@ -919,29 +919,29 @@
                             }
                         }
 
-                        var i
+                        let i
                         if (dir) {
-                            var foundIndex = -1
+                            let foundIndex = -1
                             for (i = byteOffset; i < arrLength; i++) {
                                 if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
-                                    if (foundIndex === -1) foundIndex = i
-                                    if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
+                                    if (foundIndex === -1) { foundIndex = i }
+                                    if (i - foundIndex + 1 === valLength) { return foundIndex * indexSize }
                                 } else {
-                                    if (foundIndex !== -1) i -= i - foundIndex
+                                    if (foundIndex !== -1) { i -= i - foundIndex }
                                     foundIndex = -1
                                 }
                             }
                         } else {
-                            if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
+                            if (byteOffset + valLength > arrLength) { byteOffset = arrLength - valLength }
                             for (i = byteOffset; i >= 0; i--) {
-                                var found = true
-                                for (var j = 0; j < valLength; j++) {
+                                let found = true
+                                for (let j = 0; j < valLength; j++) {
                                     if (read(arr, i + j) !== read(val, j)) {
                                         found = false
                                         break
                                     }
                                 }
-                                if (found) return i
+                                if (found) { return i }
                             }
                         }
 
@@ -962,7 +962,7 @@
 
                     function hexWrite(buf, string, offset, length) {
                         offset = Number(offset) || 0
-                        var remaining = buf.length - offset
+                        let remaining = buf.length - offset
                         if (!length) {
                             length = remaining
                         } else {
@@ -972,14 +972,14 @@
                             }
                         }
 
-                        var strLen = string.length
+                        let strLen = string.length
 
                         if (length > strLen / 2) {
                             length = strLen / 2
                         }
-                        for (var i = 0; i < length; ++i) {
-                            var parsed = parseInt(string.substr(i * 2, 2), 16)
-                            if (numberIsNaN(parsed)) return i
+                        for (let i = 0; i < length; ++i) {
+                            let parsed = parseInt(string.substr(i * 2, 2), 16)
+                            if (numberIsNaN(parsed)) { return i }
                             buf[offset + i] = parsed
                         }
                         return i
@@ -1021,7 +1021,7 @@
                             offset = offset >>> 0
                             if (isFinite(length)) {
                                 length = length >>> 0
-                                if (encoding === undefined) encoding = 'utf8'
+                                if (encoding === undefined) { encoding = 'utf8' }
                             } else {
                                 encoding = length
                                 length = undefined
@@ -1032,16 +1032,16 @@
                             )
                         }
 
-                        var remaining = this.length - offset
-                        if (length === undefined || length > remaining) length = remaining
+                        let remaining = this.length - offset
+                        if (length === undefined || length > remaining) { length = remaining }
 
                         if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
                             throw new RangeError('Attempt to write outside buffer bounds')
                         }
 
-                        if (!encoding) encoding = 'utf8'
+                        if (!encoding) { encoding = 'utf8' }
 
-                        var loweredCase = false
+                        let loweredCase = false
                         for (; ;) {
                             switch (encoding) {
                                 case 'hex':
@@ -1069,7 +1069,7 @@
                                     return ucs2Write(this, string, offset, length)
 
                                 default:
-                                    if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
+                                    if (loweredCase) { throw new TypeError('Unknown encoding: ' + encoding) }
                                     encoding = ('' + encoding).toLowerCase()
                                     loweredCase = true
                             }
@@ -1093,19 +1093,19 @@
 
                     function utf8Slice(buf, start, end) {
                         end = Math.min(buf.length, end)
-                        var res = []
+                        let res = []
 
-                        var i = start
+                        let i = start
                         while (i < end) {
-                            var firstByte = buf[i]
-                            var codePoint = null
-                            var bytesPerSequence = (firstByte > 0xEF) ? 4
+                            let firstByte = buf[i]
+                            let codePoint = null
+                            let bytesPerSequence = (firstByte > 0xEF) ? 4
                                 : (firstByte > 0xDF) ? 3
                                     : (firstByte > 0xBF) ? 2
                                         : 1
 
                             if (i + bytesPerSequence <= end) {
-                                var secondByte, thirdByte, fourthByte, tempCodePoint
+                                let secondByte, thirdByte, fourthByte, tempCodePoint
 
                                 switch (bytesPerSequence) {
                                     case 1:
@@ -1167,17 +1167,17 @@
                     // Based on http://stackoverflow.com/a/22747272/680742, the browser with
                     // the lowest limit is Chrome, with 0x10000 args.
                     // We go 1 magnitude less, for safety
-                    var MAX_ARGUMENTS_LENGTH = 0x1000
+                    let MAX_ARGUMENTS_LENGTH = 0x1000
 
                     function decodeCodePointsArray(codePoints) {
-                        var len = codePoints.length
+                        let len = codePoints.length
                         if (len <= MAX_ARGUMENTS_LENGTH) {
                             return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
                         }
 
                         // Decode in chunks to avoid "call stack size exceeded".
-                        var res = ''
-                        var i = 0
+                        let res = ''
+                        let i = 0
                         while (i < len) {
                             res += String.fromCharCode.apply(
                                 String,
@@ -1188,69 +1188,69 @@
                     }
 
                     function asciiSlice(buf, start, end) {
-                        var ret = ''
+                        let ret = ''
                         end = Math.min(buf.length, end)
 
-                        for (var i = start; i < end; ++i) {
+                        for (let i = start; i < end; ++i) {
                             ret += String.fromCharCode(buf[i] & 0x7F)
                         }
                         return ret
                     }
 
                     function latin1Slice(buf, start, end) {
-                        var ret = ''
+                        let ret = ''
                         end = Math.min(buf.length, end)
 
-                        for (var i = start; i < end; ++i) {
+                        for (let i = start; i < end; ++i) {
                             ret += String.fromCharCode(buf[i])
                         }
                         return ret
                     }
 
                     function hexSlice(buf, start, end) {
-                        var len = buf.length
+                        let len = buf.length
 
-                        if (!start || start < 0) start = 0
-                        if (!end || end < 0 || end > len) end = len
+                        if (!start || start < 0) { start = 0 }
+                        if (!end || end < 0 || end > len) { end = len }
 
-                        var out = ''
-                        for (var i = start; i < end; ++i) {
+                        let out = ''
+                        for (let i = start; i < end; ++i) {
                             out += toHex(buf[i])
                         }
                         return out
                     }
 
                     function utf16leSlice(buf, start, end) {
-                        var bytes = buf.slice(start, end)
-                        var res = ''
-                        for (var i = 0; i < bytes.length; i += 2) {
+                        let bytes = buf.slice(start, end)
+                        let res = ''
+                        for (let i = 0; i < bytes.length; i += 2) {
                             res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
                         }
                         return res
                     }
 
                     Buffer.prototype.slice = function slice(start, end) {
-                        var len = this.length
+                        let len = this.length
                         start = ~~start
                         end = end === undefined ? len : ~~end
 
                         if (start < 0) {
                             start += len
-                            if (start < 0) start = 0
+                            if (start < 0) { start = 0 }
                         } else if (start > len) {
                             start = len
                         }
 
                         if (end < 0) {
                             end += len
-                            if (end < 0) end = 0
+                            if (end < 0) { end = 0 }
                         } else if (end > len) {
                             end = len
                         }
 
-                        if (end < start) end = start
+                        if (end < start) { end = start }
 
-                        var newBuf = this.subarray(start, end)
+                        let newBuf = this.subarray(start, end)
                         // Return an augmented `Uint8Array` instance
                         newBuf.__proto__ = Buffer.prototype
                         return newBuf
@@ -1260,18 +1260,18 @@
                      * Need to make sure that buffer isn't trying to write out of bounds.
                      */
                     function checkOffset(offset, ext, length) {
-                        if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
-                        if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
+                        if ((offset % 1) !== 0 || offset < 0) { throw new RangeError('offset is not uint') }
+                        if (offset + ext > length) { throw new RangeError('Trying to access beyond buffer length') }
                     }
 
                     Buffer.prototype.readUIntLE = function readUIntLE(offset, byteLength, noAssert) {
                         offset = offset >>> 0
                         byteLength = byteLength >>> 0
-                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+                        if (!noAssert) { checkOffset(offset, byteLength, this.length) }
 
-                        var val = this[offset]
-                        var mul = 1
-                        var i = 0
+                        let val = this[offset]
+                        let mul = 1
+                        let i = 0
                         while (++i < byteLength && (mul *= 0x100)) {
                             val += this[offset + i] * mul
                         }
@@ -1286,8 +1286,8 @@
                             checkOffset(offset, byteLength, this.length)
                         }
 
-                        var val = this[offset + --byteLength]
-                        var mul = 1
+                        let val = this[offset + --byteLength]
+                        let mul = 1
                         while (byteLength > 0 && (mul *= 0x100)) {
                             val += this[offset + --byteLength] * mul
                         }
@@ -1297,25 +1297,25 @@
 
                     Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 1, this.length)
+                        if (!noAssert) { checkOffset(offset, 1, this.length) }
                         return this[offset]
                     }
 
                     Buffer.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        if (!noAssert) { checkOffset(offset, 2, this.length) }
                         return this[offset] | (this[offset + 1] << 8)
                     }
 
                     Buffer.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 2, this.length)
+                        if (!noAssert) { checkOffset(offset, 2, this.length) }
                         return (this[offset] << 8) | this[offset + 1]
                     }
 
                     Buffer.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
 
                         return ((this[offset]) |
                             (this[offset + 1] << 8) |
@@ -1325,7 +1325,7 @@
 
                     Buffer.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
 
                         return (this[offset] * 0x1000000) +
                             ((this[offset + 1] << 16) |
@@ -1336,17 +1336,17 @@
                     Buffer.prototype.readIntLE = function readIntLE(offset, byteLength, noAssert) {
                         offset = offset >>> 0
                         byteLength = byteLength >>> 0
-                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+                        if (!noAssert) { checkOffset(offset, byteLength, this.length) }
 
-                        var val = this[offset]
-                        var mul = 1
-                        var i = 0
+                        let val = this[offset]
+                        let mul = 1
+                        let i = 0
                         while (++i < byteLength && (mul *= 0x100)) {
                             val += this[offset + i] * mul
                         }
                         mul *= 0x80
 
-                        if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+                        if (val >= mul) { val -= Math.pow(2, 8 * byteLength) }
 
                         return val
                     }
@@ -1354,45 +1354,45 @@
                     Buffer.prototype.readIntBE = function readIntBE(offset, byteLength, noAssert) {
                         offset = offset >>> 0
                         byteLength = byteLength >>> 0
-                        if (!noAssert) checkOffset(offset, byteLength, this.length)
+                        if (!noAssert) { checkOffset(offset, byteLength, this.length) }
 
-                        var i = byteLength
-                        var mul = 1
-                        var val = this[offset + --i]
+                        let i = byteLength
+                        let mul = 1
+                        let val = this[offset + --i]
                         while (i > 0 && (mul *= 0x100)) {
                             val += this[offset + --i] * mul
                         }
                         mul *= 0x80
 
-                        if (val >= mul) val -= Math.pow(2, 8 * byteLength)
+                        if (val >= mul) { val -= Math.pow(2, 8 * byteLength) }
 
                         return val
                     }
 
                     Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 1, this.length)
-                        if (!(this[offset] & 0x80)) return (this[offset])
+                        if (!noAssert) { checkOffset(offset, 1, this.length) }
+                        if (!(this[offset] & 0x80)) { return (this[offset]) }
                         return ((0xff - this[offset] + 1) * -1)
                     }
 
                     Buffer.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 2, this.length)
-                        var val = this[offset] | (this[offset + 1] << 8)
+                        if (!noAssert) { checkOffset(offset, 2, this.length) }
+                        let val = this[offset] | (this[offset + 1] << 8)
                         return (val & 0x8000) ? val | 0xFFFF0000 : val
                     }
 
                     Buffer.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 2, this.length)
-                        var val = this[offset + 1] | (this[offset] << 8)
+                        if (!noAssert) { checkOffset(offset, 2, this.length) }
+                        let val = this[offset + 1] | (this[offset] << 8)
                         return (val & 0x8000) ? val | 0xFFFF0000 : val
                     }
 
                     Buffer.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
 
                         return (this[offset]) |
                             (this[offset + 1] << 8) |
@@ -1402,7 +1402,7 @@
 
                     Buffer.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
 
                         return (this[offset] << 24) |
                             (this[offset + 1] << 16) |
@@ -1412,32 +1412,32 @@
 
                     Buffer.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
                         return ieee754.read(this, offset, true, 23, 4)
                     }
 
                     Buffer.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 4, this.length)
+                        if (!noAssert) { checkOffset(offset, 4, this.length) }
                         return ieee754.read(this, offset, false, 23, 4)
                     }
 
                     Buffer.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 8, this.length)
+                        if (!noAssert) { checkOffset(offset, 8, this.length) }
                         return ieee754.read(this, offset, true, 52, 8)
                     }
 
                     Buffer.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
                         offset = offset >>> 0
-                        if (!noAssert) checkOffset(offset, 8, this.length)
+                        if (!noAssert) { checkOffset(offset, 8, this.length) }
                         return ieee754.read(this, offset, false, 52, 8)
                     }
 
                     function checkInt(buf, value, offset, ext, max, min) {
-                        if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
-                        if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
-                        if (offset + ext > buf.length) throw new RangeError('Index out of range')
+                        if (!Buffer.isBuffer(buf)) { throw new TypeError('"buffer" argument must be a Buffer instance') }
+                        if (value > max || value < min) { throw new RangeError('"value" argument is out of bounds') }
+                        if (offset + ext > buf.length) { throw new RangeError('Index out of range') }
                     }
 
                     Buffer.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength, noAssert) {
@@ -1445,12 +1445,12 @@
                         offset = offset >>> 0
                         byteLength = byteLength >>> 0
                         if (!noAssert) {
-                            var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                            let maxBytes = Math.pow(2, 8 * byteLength) - 1
                             checkInt(this, value, offset, byteLength, maxBytes, 0)
                         }
 
-                        var mul = 1
-                        var i = 0
+                        let mul = 1
+                        let i = 0
                         this[offset] = value & 0xFF
                         while (++i < byteLength && (mul *= 0x100)) {
                             this[offset + i] = (value / mul) & 0xFF
@@ -1464,12 +1464,12 @@
                         offset = offset >>> 0
                         byteLength = byteLength >>> 0
                         if (!noAssert) {
-                            var maxBytes = Math.pow(2, 8 * byteLength) - 1
+                            let maxBytes = Math.pow(2, 8 * byteLength) - 1
                             checkInt(this, value, offset, byteLength, maxBytes, 0)
                         }
 
-                        var i = byteLength - 1
-                        var mul = 1
+                        let i = byteLength - 1
+                        let mul = 1
                         this[offset + i] = value & 0xFF
                         while (--i >= 0 && (mul *= 0x100)) {
                             this[offset + i] = (value / mul) & 0xFF
@@ -1481,7 +1481,7 @@
                     Buffer.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
+                        if (!noAssert) { checkInt(this, value, offset, 1, 0xff, 0) }
                         this[offset] = (value & 0xff)
                         return offset + 1
                     }
@@ -1489,7 +1489,7 @@
                     Buffer.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+                        if (!noAssert) { checkInt(this, value, offset, 2, 0xffff, 0) }
                         this[offset] = (value & 0xff)
                         this[offset + 1] = (value >>> 8)
                         return offset + 2
@@ -1498,7 +1498,7 @@
                     Buffer.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
+                        if (!noAssert) { checkInt(this, value, offset, 2, 0xffff, 0) }
                         this[offset] = (value >>> 8)
                         this[offset + 1] = (value & 0xff)
                         return offset + 2
@@ -1507,7 +1507,7 @@
                     Buffer.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+                        if (!noAssert) { checkInt(this, value, offset, 4, 0xffffffff, 0) }
                         this[offset + 3] = (value >>> 24)
                         this[offset + 2] = (value >>> 16)
                         this[offset + 1] = (value >>> 8)
@@ -1518,7 +1518,7 @@
                     Buffer.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
+                        if (!noAssert) { checkInt(this, value, offset, 4, 0xffffffff, 0) }
                         this[offset] = (value >>> 24)
                         this[offset + 1] = (value >>> 16)
                         this[offset + 2] = (value >>> 8)
@@ -1530,14 +1530,14 @@
                         value = +value
                         offset = offset >>> 0
                         if (!noAssert) {
-                            var limit = Math.pow(2, (8 * byteLength) - 1)
+                            let limit = Math.pow(2, (8 * byteLength) - 1)
 
                             checkInt(this, value, offset, byteLength, limit - 1, -limit)
                         }
 
-                        var i = 0
-                        var mul = 1
-                        var sub = 0
+                        let i = 0
+                        let mul = 1
+                        let sub = 0
                         this[offset] = value & 0xFF
                         while (++i < byteLength && (mul *= 0x100)) {
                             if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
@@ -1553,14 +1553,14 @@
                         value = +value
                         offset = offset >>> 0
                         if (!noAssert) {
-                            var limit = Math.pow(2, (8 * byteLength) - 1)
+                            let limit = Math.pow(2, (8 * byteLength) - 1)
 
                             checkInt(this, value, offset, byteLength, limit - 1, -limit)
                         }
 
-                        var i = byteLength - 1
-                        var mul = 1
-                        var sub = 0
+                        let i = byteLength - 1
+                        let mul = 1
+                        let sub = 0
                         this[offset + i] = value & 0xFF
                         while (--i >= 0 && (mul *= 0x100)) {
                             if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
@@ -1575,8 +1575,8 @@
                     Buffer.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
-                        if (value < 0) value = 0xff + value + 1
+                        if (!noAssert) { checkInt(this, value, offset, 1, 0x7f, -0x80) }
+                        if (value < 0) { value = 0xff + value + 1 }
                         this[offset] = (value & 0xff)
                         return offset + 1
                     }
@@ -1584,7 +1584,7 @@
                     Buffer.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+                        if (!noAssert) { checkInt(this, value, offset, 2, 0x7fff, -0x8000) }
                         this[offset] = (value & 0xff)
                         this[offset + 1] = (value >>> 8)
                         return offset + 2
@@ -1593,7 +1593,7 @@
                     Buffer.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
+                        if (!noAssert) { checkInt(this, value, offset, 2, 0x7fff, -0x8000) }
                         this[offset] = (value >>> 8)
                         this[offset + 1] = (value & 0xff)
                         return offset + 2
@@ -1602,7 +1602,7 @@
                     Buffer.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
+                        if (!noAssert) { checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) }
                         this[offset] = (value & 0xff)
                         this[offset + 1] = (value >>> 8)
                         this[offset + 2] = (value >>> 16)
@@ -1613,8 +1613,8 @@
                     Buffer.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
                         value = +value
                         offset = offset >>> 0
-                        if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
-                        if (value < 0) value = 0xffffffff + value + 1
+                        if (!noAssert) { checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000) }
+                        if (value < 0) { value = 0xffffffff + value + 1 }
                         this[offset] = (value >>> 24)
                         this[offset + 1] = (value >>> 16)
                         this[offset + 2] = (value >>> 8)
@@ -1623,8 +1623,8 @@
                     }
 
                     function checkIEEE754(buf, value, offset, ext, max, min) {
-                        if (offset + ext > buf.length) throw new RangeError('Index out of range')
-                        if (offset < 0) throw new RangeError('Index out of range')
+                        if (offset + ext > buf.length) { throw new RangeError('Index out of range') }
+                        if (offset < 0) { throw new RangeError('Index out of range') }
                     }
 
                     function writeFloat(buf, value, offset, littleEndian, noAssert) {
@@ -1665,38 +1665,38 @@
 
                     // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
                     Buffer.prototype.copy = function copy(target, targetStart, start, end) {
-                        if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
-                        if (!start) start = 0
-                        if (!end && end !== 0) end = this.length
-                        if (targetStart >= target.length) targetStart = target.length
-                        if (!targetStart) targetStart = 0
-                        if (end > 0 && end < start) end = start
+                        if (!Buffer.isBuffer(target)) { throw new TypeError('argument should be a Buffer') }
+                        if (!start) { start = 0 }
+                        if (!end && end !== 0) { end = this.length }
+                        if (targetStart >= target.length) { targetStart = target.length }
+                        if (!targetStart) { targetStart = 0 }
+                        if (end > 0 && end < start) { end = start }
 
                         // Copy 0 bytes; we're done
-                        if (end === start) return 0
-                        if (target.length === 0 || this.length === 0) return 0
+                        if (end === start) { return 0 }
+                        if (target.length === 0 || this.length === 0) { return 0 }
 
                         // Fatal error conditions
                         if (targetStart < 0) {
                             throw new RangeError('targetStart out of bounds')
                         }
-                        if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
-                        if (end < 0) throw new RangeError('sourceEnd out of bounds')
+                        if (start < 0 || start >= this.length) { throw new RangeError('Index out of range') }
+                        if (end < 0) { throw new RangeError('sourceEnd out of bounds') }
 
                         // Are we oob?
-                        if (end > this.length) end = this.length
+                        if (end > this.length) { end = this.length }
                         if (target.length - targetStart < end - start) {
                             end = target.length - targetStart + start
                         }
 
-                        var len = end - start
+                        let len = end - start
 
                         if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
                             // Use built-in when available, missing from IE11
                             this.copyWithin(targetStart, start, end)
                         } else if (this === target && start < targetStart && targetStart < end) {
                             // descending copy from end
-                            for (var i = len - 1; i >= 0; --i) {
+                            for (let i = len - 1; i >= 0; --i) {
                                 target[i + targetStart] = this[i + start]
                             }
                         } else {
@@ -1732,7 +1732,7 @@
                                 throw new TypeError('Unknown encoding: ' + encoding)
                             }
                             if (val.length === 1) {
-                                var code = val.charCodeAt(0)
+                                let code = val.charCodeAt(0)
                                 if ((encoding === 'utf8' && code < 128) ||
                                     encoding === 'latin1') {
                                     // Fast path: If `val` fits into a single byte, use that numeric value.
@@ -1755,18 +1755,18 @@
                         start = start >>> 0
                         end = end === undefined ? this.length : end >>> 0
 
-                        if (!val) val = 0
+                        if (!val) { val = 0 }
 
-                        var i
+                        let i
                         if (typeof val === 'number') {
                             for (i = start; i < end; ++i) {
                                 this[i] = val
                             }
                         } else {
-                            var bytes = Buffer.isBuffer(val)
+                            let bytes = Buffer.isBuffer(val)
                                 ? val
                                 : Buffer.from(val, encoding)
-                            var len = bytes.length
+                            let len = bytes.length
                             if (len === 0) {
                                 throw new TypeError('The value "' + val +
                                     '" is invalid for argument "value"')
@@ -1782,7 +1782,7 @@
                     // HELPER FUNCTIONS
                     // ================
 
-                    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
+                    let INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
 
                     function base64clean(str) {
                         // Node takes equal signs as end of the Base64 encoding
@@ -1790,7 +1790,7 @@
                         // Node strips out invalid characters like \n and \t from the string, base64-js does not
                         str = str.trim().replace(INVALID_BASE64_RE, '')
                         // Node converts strings with length < 2 to ''
-                        if (str.length < 2) return ''
+                        if (str.length < 2) { return '' }
                         // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
                         while (str.length % 4 !== 0) {
                             str = str + '='
@@ -1799,18 +1799,18 @@
                     }
 
                     function toHex(n) {
-                        if (n < 16) return '0' + n.toString(16)
+                        if (n < 16) { return '0' + n.toString(16) }
                         return n.toString(16)
                     }
 
                     function utf8ToBytes(string, units) {
                         units = units || Infinity
-                        var codePoint
-                        var length = string.length
-                        var leadSurrogate = null
-                        var bytes = []
+                        let codePoint
+                        let length = string.length
+                        let leadSurrogate = null
+                        let bytes = []
 
-                        for (var i = 0; i < length; ++i) {
+                        for (let i = 0; i < length; ++i) {
                             codePoint = string.charCodeAt(i)
 
                             // is surrogate component
@@ -1820,11 +1820,11 @@
                                     // no lead yet
                                     if (codePoint > 0xDBFF) {
                                         // unexpected trail
-                                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                        if ((units -= 3) > -1) { bytes.push(0xEF, 0xBF, 0xBD) }
                                         continue
                                     } else if (i + 1 === length) {
                                         // unpaired lead
-                                        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                        if ((units -= 3) > -1) { bytes.push(0xEF, 0xBF, 0xBD) }
                                         continue
                                     }
 
@@ -1836,7 +1836,7 @@
 
                                 // 2 leads in a row
                                 if (codePoint < 0xDC00) {
-                                    if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                    if ((units -= 3) > -1) { bytes.push(0xEF, 0xBF, 0xBD) }
                                     leadSurrogate = codePoint
                                     continue
                                 }
@@ -1845,30 +1845,30 @@
                                 codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
                             } else if (leadSurrogate) {
                                 // valid bmp char, but last char was a lead
-                                if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
+                                if ((units -= 3) > -1) { bytes.push(0xEF, 0xBF, 0xBD) }
                             }
 
                             leadSurrogate = null
 
                             // encode utf8
                             if (codePoint < 0x80) {
-                                if ((units -= 1) < 0) break
+                                if ((units -= 1) < 0) { break }
                                 bytes.push(codePoint)
                             } else if (codePoint < 0x800) {
-                                if ((units -= 2) < 0) break
+                                if ((units -= 2) < 0) { break }
                                 bytes.push(
                                     codePoint >> 0x6 | 0xC0,
                                     codePoint & 0x3F | 0x80
                                 )
                             } else if (codePoint < 0x10000) {
-                                if ((units -= 3) < 0) break
+                                if ((units -= 3) < 0) { break }
                                 bytes.push(
                                     codePoint >> 0xC | 0xE0,
                                     codePoint >> 0x6 & 0x3F | 0x80,
                                     codePoint & 0x3F | 0x80
                                 )
                             } else if (codePoint < 0x110000) {
-                                if ((units -= 4) < 0) break
+                                if ((units -= 4) < 0) { break }
                                 bytes.push(
                                     codePoint >> 0x12 | 0xF0,
                                     codePoint >> 0xC & 0x3F | 0x80,
@@ -1884,8 +1884,8 @@
                     }
 
                     function asciiToBytes(str) {
-                        var byteArray = []
-                        for (var i = 0; i < str.length; ++i) {
+                        let byteArray = []
+                        for (let i = 0; i < str.length; ++i) {
                             // Node's code seems to be doing this and not & 0x7F..
                             byteArray.push(str.charCodeAt(i) & 0xFF)
                         }
@@ -1893,10 +1893,10 @@
                     }
 
                     function utf16leToBytes(str, units) {
-                        var c, hi, lo
-                        var byteArray = []
-                        for (var i = 0; i < str.length; ++i) {
-                            if ((units -= 2) < 0) break
+                        let c, hi, lo
+                        let byteArray = []
+                        for (let i = 0; i < str.length; ++i) {
+                            if ((units -= 2) < 0) { break }
 
                             c = str.charCodeAt(i)
                             hi = c >> 8
@@ -1913,8 +1913,8 @@
                     }
 
                     function blitBuffer(src, dst, offset, length) {
-                        for (var i = 0; i < length; ++i) {
-                            if ((i + offset >= dst.length) || (i >= src.length)) break
+                        for (let i = 0; i < length; ++i) {
+                            if ((i + offset >= dst.length) || (i >= src.length)) { break }
                             dst[i + offset] = src[i]
                         }
                         return i
@@ -1938,14 +1938,14 @@
         }, { "base64-js": 1, "buffer": 2, "ieee754": 3 }], 3: [function (require, module, exports) {
             /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
             exports.read = function (buffer, offset, isLE, mLen, nBytes) {
-                var e, m
-                var eLen = (nBytes * 8) - mLen - 1
-                var eMax = (1 << eLen) - 1
-                var eBias = eMax >> 1
-                var nBits = -7
-                var i = isLE ? (nBytes - 1) : 0
-                var d = isLE ? -1 : 1
-                var s = buffer[offset + i]
+                let e, m
+                let eLen = (nBytes * 8) - mLen - 1
+                let eMax = (1 << eLen) - 1
+                let eBias = eMax >> 1
+                let nBits = -7
+                let i = isLE ? (nBytes - 1) : 0
+                let d = isLE ? -1 : 1
+                let s = buffer[offset + i]
 
                 i += d
 
@@ -1971,14 +1971,14 @@
             }
 
             exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
-                var e, m, c
-                var eLen = (nBytes * 8) - mLen - 1
-                var eMax = (1 << eLen) - 1
-                var eBias = eMax >> 1
-                var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
-                var i = isLE ? 0 : (nBytes - 1)
-                var d = isLE ? 1 : -1
-                var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
+                let e, m, c
+                let eLen = (nBytes * 8) - mLen - 1
+                let eMax = (1 << eLen) - 1
+                let eBias = eMax >> 1
+                let rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
+                let i = isLE ? 0 : (nBytes - 1)
+                let d = isLE ? 1 : -1
+                let s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
 
                 value = Math.abs(value)
 
@@ -2035,8 +2035,8 @@
 
                     function configure(opts) {
                         function encode(packet, buf, offset) {
-                            if (!buf) buf = new Buffer(encodingLength(packet, packet.version === 4 ? 20 : 40))
-                            if (!offset) offset = 0
+                            if (!buf) { buf = new Buffer(encodingLength(packet, packet.version === 4 ? 20 : 40)) }
+                            if (!offset) { offset = 0 }
                             if (packet.version === 4) {
 
                                 // IPv4 header
@@ -2077,20 +2077,20 @@
                         }
 
                         function decode(buf, offset) {
-                            if (!offset) offset = 0
+                            if (!offset) { offset = 0 }
 
-                            var version = buf[offset] >> 4
-                            if (version !== 4) throw new Error('Currently only IPv4 is supported')
-                            var ihl = buf[offset] & 15
-                            if (ihl > 5) throw new Error('Currently only IHL <= 5 is supported')
-                            var length = buf.readUInt16BE(offset + 2)
-                            var decodedChecksum = buf.readUInt16BE(offset + 10)
-                            var ignoreChecksum = opts.allowNullChecksum && decodedChecksum === 0
+                            let version = buf[offset] >> 4
+                            if (version !== 4) { throw new Error('Currently only IPv4 is supported') }
+                            let ihl = buf[offset] & 15
+                            if (ihl > 5) { throw new Error('Currently only IHL <= 5 is supported') }
+                            let length = buf.readUInt16BE(offset + 2)
+                            let decodedChecksum = buf.readUInt16BE(offset + 10)
+                            let ignoreChecksum = opts.allowNullChecksum && decodedChecksum === 0
 
                             if (!ignoreChecksum) {
-                                var sum = checksum(buf, offset, offset + 20)
+                                let sum = checksum(buf, offset, offset + 20)
 
-                                if (sum) throw new Error('Bad checksum (' + sum + ')')
+                                if (sum) { throw new Error('Bad checksum (' + sum + ')') }
                             }
 
                             decode.bytes = length
@@ -2127,8 +2127,8 @@
                     }
 
                     function encodeIp(addr, buf, offset) {
-                        for (var i = 0; i < 4; i++) {
-                            var oct = parseInt(addr, 10)
+                        for (let i = 0; i < 4; i++) {
+                            let oct = parseInt(addr, 10)
                             buf[offset++] = oct
                             addr = addr.slice(oct < 100 ? oct < 10 ? 2 : 3 : 4)
                         }
@@ -2139,11 +2139,11 @@
                     }
 
                     function checksum(buf, offset, end) {
-                        var sum = 0
-                        for (; offset < end; offset += 2) sum += buf.readUInt16BE(offset)
+                        let sum = 0
+                        for (; offset < end; offset += 2) { sum += buf.readUInt16BE(offset) }
                         while (true) {
-                            var carry = sum >> 16
-                            if (!carry) break
+                            let carry = sum >> 16
+                            if (!carry) { break }
                             sum = (sum & 0xffff) + carry
                         }
                         return ~sum & 0xffff
@@ -2165,7 +2165,7 @@
                         packet.writeUInt32BE(sequenceNumber, 4)
                         packet.writeUInt32BE(acknowledgmentNumber, 8)
                         packet.writeUInt16BE(0x5000, 12)
-                        if (data) data.copy(packet, 20)
+                        if (data) { data.copy(packet, 20) }
                         return packet
                     }
 
@@ -2204,9 +2204,9 @@
             (function (Buffer) {
                 (function () {
                     exports.encode = function (packet) {
-                        var data = packet.data, len = data.length
-                        var srcport = packet.sourcePort, dstport = packet.destinationPort
-                        var buf = Buffer.alloc(len + 8)
+                        let data = packet.data, len = data.length
+                        let srcport = packet.sourcePort, dstport = packet.destinationPort
+                        let buf = Buffer.alloc(len + 8)
                         buf.writeUInt16BE(srcport, 0)
                         buf.writeUInt16BE(dstport, 2)
                         buf.writeUInt16BE(buf.length, 4)
@@ -2216,7 +2216,7 @@
                     }
 
                     exports.decode = function (buf) {
-                        var len = buf.readUInt16BE(4)
+                        let len = buf.readUInt16BE(4)
                         return {
                             sourcePort: buf.readUInt16BE(0),
                             destinationPort: buf.readUInt16BE(2),
@@ -2229,26 +2229,26 @@
                     exports.checksum = checksum
                     function checksum(packet, buf) {
                         // pseudo header: srcip (16), dstip (16), 0 (8), proto (8), udp len (16)
-                        var len = buf.length
-                        var srcip = packet.sourceIp
-                        var dstip = packet.destinationIp
-                        if (!srcip || !dstip) return 0xffff
-                        var protocol = packet.protocol === undefined ? 0x11 : packet.protocol
-                        var sum = 0xffff
+                        let len = buf.length
+                        let srcip = packet.sourceIp
+                        let dstip = packet.destinationIp
+                        if (!srcip || !dstip) { return 0xffff }
+                        let protocol = packet.protocol === undefined ? 0x11 : packet.protocol
+                        let sum = 0xffff
                         // pseudo header: srcip (16), dstip (16), 0 (8), proto (8), udp len (16)
                         if (srcip && dstip) {
-                            if (typeof srcip === 'string') srcip = Buffer.from(srcip.split('.'))
-                            if (typeof dstip === 'string') dstip = Buffer.from(dstip.split('.'))
+                            if (typeof srcip === 'string') { srcip = Buffer.from(srcip.split('.')) }
+                            if (typeof dstip === 'string') { dstip = Buffer.from(dstip.split('.')) }
                             sum = 0
-                            var pad = len % 2
-                            for (var i = 0; i < len + pad; i += 2) {
-                                if (i === 6) continue // ignore the currently written checksum
+                            let pad = len % 2
+                            for (let i = 0; i < len + pad; i += 2) {
+                                if (i === 6) { continue } // ignore the currently written checksum
                                 sum += ((buf[i] << 8) & 0xff00) + ((buf[i + 1]) & 0xff)
                             }
-                            for (var i = 0; i < 4; i += 2) {
+                            for (let i = 0; i < 4; i += 2) {
                                 sum += ((srcip[i] << 8) & 0xff00) + (srcip[i + 1] & 0xff)
                             }
-                            for (var i = 0; i < 4; i += 2) {
+                            for (let i = 0; i < 4; i += 2) {
                                 sum += ((dstip[i] << 8) & 0xff00) + (dstip[i + 1] & 0xff)
                             }
                             sum += protocol + len

From f1b0c76a90a8a8aa516bb0b2c46d2c3eaf686097 Mon Sep 17 00:00:00 2001
From: AlexeyOplachko <xirenec1@gmail.com>
Date: Wed, 7 Feb 2024 19:36:28 +0200
Subject: [PATCH 5/8] fix: enabled virtual scroll for non-safari browsers

# Conflicts:
#	ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
---
 .../src/tab-flow/tab-flow.component.html      | 107 ++++++++++++------
 .../src/tab-flow/tab-flow.component.scss      |   2 +
 .../src/tab-flow/tab-flow.component.ts        |   3 +-
 3 files changed, 75 insertions(+), 37 deletions(-)

diff --git a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
index 60d5f76..33ec959 100644
--- a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
+++ b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.html
@@ -61,46 +61,81 @@ <h1 style="text-align: center; padding: 8rem; color: #aaa">No Data</h1>
     </div>
 </div>
 <div class="VS-Container-horizontal">
-    <div *ngIf="isExport || isSafari" class="VS-Container" style="overflow: auto !important"
-        (scroll)="onScrollVScrollWrapper($event)">
-        <div class="VS-Container" style="height: initial; overflow: scroll !important; bottom:unset"
-            [style.min-width.px]="pageWidth + 100">
-            <div style="height: 92px"></div>
-            <app-flow-item *ngFor="let item of arrayItems; let idx = index" [item]="item" [idx]="idx"
-                [isGroupByAlias]="_isCombineByAlias" [isSimplify]="isSimplify" [isAbsolute]="isAbsolute"
-                (itemClick)="onClickMessage($event.idx, $event.event, item)"></app-flow-item>
-            <div style="height: 60px"></div>
-        </div>
-    </div>
-    <div class="VS-Container" style="overflow-y: hidden !important" (scroll)="onScrollVScrollWrapper($event)"
-        *ngIf="!isExport && !isSafari" #VScrollWrapper>
-        <cdk-virtual-scroll-viewport class="VS-Container hidescroll" (wheel)="cdkWheelScroll($event)"
-            (touchstart)="onEvent($event, 'touchstart')" (touchmove)="onEvent($event, 'touchmove')" [maxBufferPx]="500"
-            [minBufferPx]="10" [style.min-width.px]="pageWidth + 100" #virtualScroll>
-            <ng-container *cdkVirtualFor="let item of virtualScrollerItemsArray; let idx = index"
-                [ngSwitch]="item?._step">
-                <ng-template ngSwitchCase="top">
-                    <div style="height: 92px"></div>
-                </ng-template>
-                <ng-template ngSwitchDefault>
-                    <app-flow-item [item]="item" [idx]="idx" [isGroupByAlias]="_isCombineByAlias"
-                        [isSimplify]="isSimplify" [isAbsolute]="isAbsolute"
-                        (itemClick)="onClickMessage($event.idx, $event.event, item)">
-                    </app-flow-item>
-                </ng-template>
-                <ng-template ngSwitchCase="bottom">
-                    <div style="height: 60px"></div>
-                </ng-template>
-            </ng-container>
-        </cdk-virtual-scroll-viewport>
+  <div
+  *ngIf="isExport || isSafari"
+    class="VS-Container"
+    style="overflow: auto !important"
+    (scroll)="onScrollVScrollWrapper($event)"
+  >
+    <div
+      class="VS-Container"
+      style="height: initial; overflow: scroll !important; bottom:unset"
+      [style.min-width.px]="pageWidth + 100"
+    >
+      <div style="height: 92px"></div>
+      <app-flow-item
+        *ngFor="let item of arrayItems; let idx = index"
+        [item]="item"
+        [idx]="idx"
+        [isGroupByAlias]="_isCombineByAlias"
+        [isSimplify]="isSimplify"
+        [isAbsolute]="isAbsolute"
+        (itemClick)="onClickMessage($event.idx, $event.event, item)"
+      ></app-flow-item>
+      <div style="height: 60px"></div>
     </div>
+  </div>
+   <div
+    class="VS-Container"
+    style="overflow-y: hidden !important"
+    (scroll)="onScrollVScrollWrapper($event)"
+    *ngIf="!isExport && !isSafari"
+    #VScrollWrapper
+  >
+    <cdk-virtual-scroll-viewport
+      class="VS-Container hidescroll"
+      (wheel)="cdkWheelScroll($event)"
+
+      (touchstart)="onEvent($event, 'touchstart')"
+      (touchmove)="onEvent($event, 'touchmove')"
+      [maxBufferPx]="500"
+      [minBufferPx]="10"
+      [style.min-width.px]="pageWidth + 100"
+      #virtualScroll
+    >
+      <ng-container *cdkVirtualFor="let item of virtualScrollerItemsArray; let idx = index" [ngSwitch]="item?._step">
+        <ng-template ngSwitchCase="top">
+          <div style="height: 92px"></div>
+        </ng-template>
+        <ng-template ngSwitchDefault>
+          <app-flow-item
+            [item]="item"
+            [idx]="idx"
+            [isGroupByAlias]="_isCombineByAlias"
+            [isSimplify]="isSimplify"
+            [isAbsolute]="isAbsolute"
+            (itemClick)="onClickMessage($event.idx, $event.event, item)"
+          >
+          </app-flow-item>
+        </ng-template>
+        <ng-template ngSwitchCase="bottom">
+          <div style="height: 60px"></div>
+        </ng-template>
+      </ng-container>
+    </cdk-virtual-scroll-viewport>
+  </div>
 </div>
 
 <div id="download" style="display: none">
     <img #canvas />
     <a #downloadLink target="_blank"></a>
 </div>
-<div class="virtual-scrollbar" *ngIf="!isExport && !isSafari" (mousedown)="setScrollTarget('virtualScrollbar')"
-    (scroll)="setVirtualScrollHeight($event)" #virtualScrollbar>
-    <div [style.transform]="getVirtualScrollHeight" [style.padding.px]="1"></div>
-</div>
+ <div
+  class="virtual-scrollbar"
+  *ngIf="!isExport && !isSafari"
+  (mousedown)="setScrollTarget('virtualScrollbar')"
+  (scroll)="setVirtualScrollHeight($event)"
+  #virtualScrollbar
+>
+  <div [style.transform]="getVirtualScrollHeight" [style.padding.px]="1"></div>
+</div>
diff --git a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.scss b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.scss
index 4526b24..4abbdd7 100644
--- a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.scss
+++ b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.scss
@@ -43,6 +43,8 @@
     box-shadow: inset 7px 10px 12px transparent;
   }
 }
+::-webkit-scrollbar-corner { background: rgba(0,0,0,0.5); } 
+
 
 .flow-grid-lines {
   display: flex;
diff --git a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
index 6d9798d..0869cce 100644
--- a/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
+++ b/ngx-flow/projects/ngx-flow/src/tab-flow/tab-flow.component.ts
@@ -94,6 +94,7 @@ export class TabFlowComponent
     timeout: any;
     _interval: any | null = null;
     pathPrefix = './assets/';
+    isSafari = navigator.vendor === 'Apple Computer, Inc.'
     outEventDelayOff = 0;
     get outEventOff() {
         //
@@ -701,7 +702,7 @@ export class TabFlowComponent
         const scrollbar = this.virtualScrollbar?.nativeElement;
         let movingAverageArray: any[] = [];
         const ma = (p: any) => {
-            const valMA = 6;
+            const valMA = 3; // Adjust this to change virtual scroll speed. Lower = faster
             if (movingAverageArray.length < valMA) {
                 movingAverageArray = Array.from({ length: valMA }, (x) => p);
             }

From 66313ae124d0a5d794fb76dddb9208206e6d2907 Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Tue, 19 Mar 2024 14:06:11 +0200
Subject: [PATCH 6/8] fix: style

---
 src/components/SimplePanel.tsx | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/components/SimplePanel.tsx b/src/components/SimplePanel.tsx
index 2fe2a03..4b04e01 100644
--- a/src/components/SimplePanel.tsx
+++ b/src/components/SimplePanel.tsx
@@ -437,7 +437,7 @@ export const SimplePanel: React.FC<Props> = ({ options, data, width, height }: a
                         css`
               position: absolute;
               top: 15px;
-              right: 15px;
+              right: 40px;
               border: 1px solid ${themeName === 'Dark' ? 'hsla(240, 18.6%, 83.1%, 0.12)' : 'hsla(210, 12.2%, 16.1%, 0.12)'};
               border-radius: 2px;
               background-color: ${themeName === 'Dark' ? 'hsla(0, 0%, 0%, 0.5)' : 'hsla(0, 0%, 100%, 0.5)'};

From 3353f6878b9e16da2b61c8ac536d6780d75ab9f9 Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Tue, 19 Mar 2024 14:07:29 +0200
Subject: [PATCH 7/8] 10.0.11

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index ce20818..8399db0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
     "name": "qxip-flow-panel",
-    "version": "10.1.0",
+    "version": "10.0.11",
     "description": "Test plugin to lern dev enveroument",
     "scripts": {
         "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
@@ -72,4 +72,4 @@
         "web-component-load": "^1.0.1"
     },
     "packageManager": "npm@8.19.3"
-}
+}
\ No newline at end of file

From 340d40c21886703a07a67c1851f2df3874c0e801 Mon Sep 17 00:00:00 2001
From: Alexey Oplachko <xirenec1@gmail.com>
Date: Wed, 20 Mar 2024 11:00:55 +0200
Subject: [PATCH 8/8] fix: issue introduce by lint

---
 src/libs/packets.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/libs/packets.js b/src/libs/packets.js
index 6f160cf..dbfa995 100644
--- a/src/libs/packets.js
+++ b/src/libs/packets.js
@@ -977,7 +977,8 @@
                         if (length > strLen / 2) {
                             length = strLen / 2
                         }
-                        for (let i = 0; i < length; ++i) {
+                        let i = 0
+                        for (; i < length; ++i) {
                             let parsed = parseInt(string.substr(i * 2, 2), 16)
                             if (numberIsNaN(parsed)) { return i }
                             buf[offset + i] = parsed
@@ -1913,7 +1914,8 @@
                     }
 
                     function blitBuffer(src, dst, offset, length) {
-                        for (let i = 0; i < length; ++i) {
+                        let i = 0
+                        for (; i < length; ++i) {
                             if ((i + offset >= dst.length) || (i >= src.length)) { break }
                             dst[i + offset] = src[i]
                         }