commit f024b4a3c19bf236af4fbc532c207a46a004e3a3 Author: Christian Pierre MOMON Date: Sat Mar 28 11:49:11 2020 +0100 Build 9945bc5f7 diff --git a/00fd86fe12871b707998bf7214820fdd.svg b/00fd86fe12871b707998bf7214820fdd.svg new file mode 100644 index 0000000..e9702ea --- /dev/null +++ b/00fd86fe12871b707998bf7214820fdd.svg @@ -0,0 +1,15 @@ + + + + + + + + + diff --git a/077f1c5bd335be073c48c340b01f58bc.svg b/077f1c5bd335be073c48c340b01f58bc.svg new file mode 100644 index 0000000..a6351af --- /dev/null +++ b/077f1c5bd335be073c48c340b01f58bc.svg @@ -0,0 +1,13 @@ + + + + + + + + + + + diff --git a/0ce7650c4d5a52a5323868f75588e1c7.svg b/0ce7650c4d5a52a5323868f75588e1c7.svg new file mode 100644 index 0000000..bae1168 --- /dev/null +++ b/0ce7650c4d5a52a5323868f75588e1c7.svg @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/18e00168e2eeff800227594e26818681.svg b/18e00168e2eeff800227594e26818681.svg new file mode 100644 index 0000000..8978569 --- /dev/null +++ b/18e00168e2eeff800227594e26818681.svg @@ -0,0 +1,44 @@ + + + + +Created by potrace 1.11, written by Peter Selinger 2001-2013 + + + + + + diff --git a/195ad531e2d729dbb80bb4524be18d78.png b/195ad531e2d729dbb80bb4524be18d78.png new file mode 100644 index 0000000..1fbe564 Binary files /dev/null and b/195ad531e2d729dbb80bb4524be18d78.png differ diff --git a/22ecf0ecde1ae2a6281265174b7fa355.svg b/22ecf0ecde1ae2a6281265174b7fa355.svg new file mode 100644 index 0000000..85bbbce --- /dev/null +++ b/22ecf0ecde1ae2a6281265174b7fa355.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + diff --git a/296b612d2847da52749549f73d0c3664.svg b/296b612d2847da52749549f73d0c3664.svg new file mode 100644 index 0000000..d619427 --- /dev/null +++ b/296b612d2847da52749549f73d0c3664.svg @@ -0,0 +1,15 @@ + + + + + + + + + diff --git a/32785c1d21b0050be9168487542b8c3d.svg b/32785c1d21b0050be9168487542b8c3d.svg new file mode 100644 index 0000000..a9305e2 --- /dev/null +++ b/32785c1d21b0050be9168487542b8c3d.svg @@ -0,0 +1,14 @@ + + + + + + + + diff --git a/33b990984178a1246982bd7dd605f350.css b/33b990984178a1246982bd7dd605f350.css new file mode 100644 index 0000000..ae83931 --- /dev/null +++ b/33b990984178a1246982bd7dd605f350.css @@ -0,0 +1,469 @@ +@charset "UTF-8"; +html, body { + background-color: #2c2c2c; + color: #bbb; + font-family: "Segoe UI", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif; + margin: 0; + overflow: hidden; + height: 100%; } + +#container { + height: 100%; } + +.channel-root-container { + text-size: 16px; + margin-left: 2px; + background-color: #1c1c1c; + border: 1px solid #555; + float: left; + border-radius: 3px; + overflow-x: hidden; + overflow-y: auto; } + +.toolbar-horizontal ~ .channel-root-container { + margin-top: 2px; + width: calc(59% - 6px); + height: calc(98% - 38px); } + +.toolbar-vertical ~ .channel-root-container { + margin-top: 1%; + width: calc(59% - 6px); + height: calc(98% - 6px); } + +.chat { + margin-right: 2px; + float: left; } + +.toolbar-horizontal ~ .chat { + margin-top: 2px; + margin-left: 1%; + width: 39%; + height: calc(98% - 38px); } + +.toolbar-vertical ~ .chat { + margin-top: 1%; + margin-left: 2px; + width: calc(39% - 36px); + height: calc(98% - 4px); } + +.log { + background-color: #1c1c1c; + height: calc(100% - 42px); + padding: 5px; + border: 1px #555 solid; + border-radius: 3px; + overflow-x: hidden; + overflow-y: scroll; } + +.branch img { + height: 19px; } + +.branch { + float: left; + padding-top: 3px; + padding-bottom: 3px; + background-color: #1c1c1c; } + +.channel-sub { + margin-left: 9px; + border-left: 1px transparent solid; + padding-left: 9px; } + +.channel-wrapper:nth-last-child(n + 2) > .branch:not(:empty) + .channel-sub { + border-left: 1px #555 solid; } + +.channel-tree, +.user-wrapper { + margin-left: 9px; } + +.channel-tree, +.user-tree { + float: left; } + +.channel-tree::before, +.user-tree::before { + content: ""; + display: block; + position: relative; + width: 9px; + border-left: 1px #555 solid; + border-bottom: 1px #555 solid; + height: 14px; } + +.channel-wrapper:nth-last-child(n + 2) > .channel-tree:after, +.user-wrapper:nth-last-child(n + 2) .user-tree:after { + content: ""; + display: block; + position: relative; + width: 0px; + border-left: 1px #555 solid; + height: 14px; } + +.user { + margin-left: 9px; } + +.user-avatar, .user-talk { + vertical-align: middle; } + +.user-avatar-talk-on { + filter: drop-shadow(1px 1px 1px green) drop-shadow(1px -1px 1px green) drop-shadow(-1px 1px 1px green) drop-shadow(-1px -1px 1px green); } + +.user-avatar-talk-whisper { + filter: drop-shadow(1px 1px 1px purple) drop-shadow(1px -1px 1px purple) drop-shadow(-1px 1px 1px purple) drop-shadow(-1px -1px 1px purple); } + +.user-avatar-talk-shout { + filter: drop-shadow(1px 1px 1px cyan) drop-shadow(1px -1px 1px cyan) drop-shadow(-1px 1px 1px cyan) drop-shadow(-1px -1px 1px cyan); } + +.user-status, .channel-status { + float: right; } + +.user, .channel { + height: 23px; + line-height: 23px; + padding: 2px; + border: 1px solid transparent; } + +.selected { + background-color: #557 !important; + border: 1px solid #777; + border-radius: 3px; } + +.user:hover, .channel:hover { + background-color: #555; } + +.thisClient { + font-weight: bold; } + +.currentChannel { + font-weight: bold; } + +.user-status img, .channel-status img { + margin-top: 2px; + width: 19px; + height: 19px; } + +.channel img, .user img { + width: auto; + height: 19px; } + +.channel-name, .user-name { + display: inline; } + +.channel:hover .tooltip, .user:hover .tooltip { + visibility: visible; + height: auto; + transition-delay: 1s; } + +.tooltip { + visibility: hidden; + height: 0px; + background: #1c1c1c; + border: 1px solid #777; + margin-top: 16px; + margin-left: 30px; + padding: 10px; + position: absolute; + z-index: 100; } + +.context-menu { + position: absolute; + z-index: 50; + background: #2c2c2c; + border: 1px solid #555; + margin: 0; + padding: 0; + list-style: none; } + .context-menu > li { + padding: 5px 20px; + padding-left: 10px; } + .context-menu > li::before { + display: inline-block; + width: 10px; + padding-right: 5px; + content: ''; } + .context-menu > li.checked::before { + content: '\2713'; } + .context-menu > li:hover { + background: #557; } + .context-menu > li.disabled { + background: #2c2c2c; + color: #555; } + +.avatar-view { + position: absolute; + z-index: 200; + max-width: 90%; + max-height: 90%; + top: 0; + bottom: 0; + left: 0; + right: 0; + margin: auto; } + +.toolbar { + display: flex; + align-items: center; } + +.toolbar img { + height: 28px; + width: 28px; + padding: 2px; + border: 1px solid transparent; + border-radius: 3px; } + +.toolbar img:hover { + border: 1px solid #557; + background-color: #557; } + +.toolbar .tb-active { + border: 1px solid #555; + background-color: #555; } + +.toolbar-horizontal { + flex-direction: row; + height: 36px; + margin-top: 4px; + margin-left: 1%; + padding-left: 5px; } + +.toolbar-vertical { + flex-direction: column; + width: 36px; + margin-top: 1%; + margin-left: 4px; + padding-top: 5px; + float: left; } + +.toolbar-horizontal > * { + margin-right: 5px; } + +.toolbar-vertical > * { + margin-bottom: 5px; } + +.divider { + display: inline-block; } + +.toolbar-horizontal .divider { + height: 32px; + border-left: 1px #555 solid; } + +.toolbar-vertical .divider { + width: 32px; + border-top: 1px #555 solid; } + +.toolbar-horizontal .handle-horizontal { + width: auto !important; + border: none !important; + background-color: #2c2c2c !important; } + +.toolbar-horizontal .handle-vertical { + display: none; } + +.toolbar-vertical .handle-vertical { + height: auto !important; + border: none !important; + background-color: #2c2c2c !important; } + +.toolbar-vertical .handle-horizontal { + display: none; } + +.channel-icon .channel-icon-active { + display: none; } + +.channel-tag { + font-weight: bold; + color: orange; } + +.user-tag { + font-weight: bold; + color: green; } + +#message-box { + width: 100%; + border: none; + background: none; + color: #bbb; + margin: 5px 0 5px 0; + padding: 0; + height: 20px; } + +form { + margin: 0; + padding: 0; } + +.message-content p { + margin: 0; } + +.tb-information.disabled, .tb-record, .tb-comment { + filter: grayscale(100%); } + +.dialog-header { + height: 20px; + width: calc(100% - 10px); + padding: 5px; + text-align: center; + color: #1c1c1c; + background-color: #777; + border-bottom: 1px solid #555; } + +.dialog-footer { + width: calc(100% - 20px); + margin: 10px; } + +.dialog-submit { + float: right; } + +.dialog-close, .dialog-submit { + width: 45%; + font-size: 15px; + border: 1px #777 solid; + border-radius: 3px; + background-color: #1c1c1c; + color: #bbb; + padding: 1px; } + +.connect-dialog table { + text-align: center; + width: 100%; } + +.dialog { + position: absolute; + max-height: calc(100% - 20px); + max-width: calc(100% - 20px); + top: 50%; + left: 50%; + transform: translate(-50%, -50%); + overflow: auto; + background-color: #2c2c2c; + color: #bbb; + border: 1px #777 solid; + box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.25); + z-index: 20; } + +.settings-dialog table { + width: 100%; + padding: 5px; } + +.settings-dialog td { + width: 50%; } + +.settings-dialog table select { + width: 100%; } + +.settings-dialog table input { + width: 100%; + margin: 0px; } + +.settings-dialog table input[type="checkbox"] { + width: auto; + margin: auto; } + +.settings-dialog .mic-volume-container { + height: 10px; + border: 3px solid #bbb; } + +.settings-dialog .mic-volume { + height: 100%; } + +.join-dialog { + width: 100%; + height: 100%; + top: 0px; + left: 0px; } + +.join-dialog .dialog-submit { + float: none; + width: 200px; + position: absolute; + top: calc(50% - 10px); + left: calc(50% - 100px); } + +.connect-dialog input[type=text], select { + font-size: 15px; + border: 1px #777 solid; + border-radius: 3px; + background-color: #1c1c1c; + color: #bbb; + padding: 2px; + width: calc(100% - 8px); } + +.connect-dialog input[type=password] { + font-size: 15px; + border: 1px #777 solid; + border-radius: 3px; + background-color: #1c1c1c; + color: #bbb; + padding: 2px; + width: calc(100% - 8px); } + +.connection-info-dialog h3 { + margin-bottom: 5px; } + +.connection-info-dialog .dialog-content { + padding-left: 20px; } + +/****************/ +/* Minimal view */ +/****************/ +.minimal .toolbar-horizontal ~ .channel-root-container { + width: calc(98% - 6px); } + +.minimal .toolbar-vertical ~ .channel-root-container { + width: calc(98% - 42px); } + +.minimal .handle-horizontal { + display: none; } + +.minimal .handle-vertical { + display: none; } + +.minimal .divider { + display: none; } + +.minimal .tb-connect { + display: none; } + +.minimal .tb-information { + display: none; } + +.minimal .tb-record { + display: none; } + +.minimal .tb-comment { + display: none; } + +.minimal .tb-settings { + display: none; } + +.minimal .tb-sourcecode { + display: none; } + +.minimal .chat { + display: none; } + +.minimal .channel-wrapper { + display: none; } + +.minimal .channel { + display: none; } + +.minimal .user-tree { + display: none; } + +.minimal .user-wrapper { + margin-left: 0px; } + +.minimal .user { + margin-left: 0px; + padding-top: 0px; + padding-bottom: 0px; + border: none; + height: 19px; + line-height: 19px; } + +.minimal .user-status { + height: 19px; } + +.dialog-header { + color: #000; + font-weight: bold; } diff --git a/50dddae19e7bf601b168f46a1303674b.svg b/50dddae19e7bf601b168f46a1303674b.svg new file mode 100644 index 0000000..f450b30 --- /dev/null +++ b/50dddae19e7bf601b168f46a1303674b.svg @@ -0,0 +1,24 @@ + + + + + + diff --git a/5b70c2cbbd6e9258a632c70b03381627.png b/5b70c2cbbd6e9258a632c70b03381627.png new file mode 100644 index 0000000..a08d992 Binary files /dev/null and b/5b70c2cbbd6e9258a632c70b03381627.png differ diff --git a/6d73bb785aa06bf0c436ad6f7cc6262a.svg b/6d73bb785aa06bf0c436ad6f7cc6262a.svg new file mode 100644 index 0000000..81b9886 --- /dev/null +++ b/6d73bb785aa06bf0c436ad6f7cc6262a.svg @@ -0,0 +1,7 @@ + + + + + + diff --git a/71edeaefdc2f5a19dc84298669af6962.svg b/71edeaefdc2f5a19dc84298669af6962.svg new file mode 100644 index 0000000..146f66f --- /dev/null +++ b/71edeaefdc2f5a19dc84298669af6962.svg @@ -0,0 +1,3 @@ + + + diff --git a/7b86c879d50808c66816ed3338f26557.svg b/7b86c879d50808c66816ed3338f26557.svg new file mode 100644 index 0000000..fee6d6d --- /dev/null +++ b/7b86c879d50808c66816ed3338f26557.svg @@ -0,0 +1,12 @@ + + + + + + + diff --git a/7dd33815bcb23cf9a0cd851c2145e169.css b/7dd33815bcb23cf9a0cd851c2145e169.css new file mode 100644 index 0000000..586fddb --- /dev/null +++ b/7dd33815bcb23cf9a0cd851c2145e169.css @@ -0,0 +1,28 @@ +.loading-container { + position: absolute; + top: 0; + width: 100%; + height: 100%; + background-color: #2c2c2c; + z-index: 1000; } + +.loading-circle { + box-sizing: border-box; + width: 80px; + height: 80px; + position: absolute; + top: calc(50% - 40px); + left: calc(50% - 40px); + border-radius: 100%; + border: 10px solid #222; + border-top-color: #888; + animation: spin 1s infinite linear; } + +@keyframes spin { + 100% { + transform: rotate(360deg); } } + +.loaded { + top: -100%; + transition: top 1s; + transition-delay: 2s; } diff --git a/7e20ba1e3b8980a164c5f557a0470919.ico b/7e20ba1e3b8980a164c5f557a0470919.ico new file mode 100644 index 0000000..7771aaa Binary files /dev/null and b/7e20ba1e3b8980a164c5f557a0470919.ico differ diff --git a/80250154041d2e9f6d50a91181409f21.png b/80250154041d2e9f6d50a91181409f21.png new file mode 100644 index 0000000..122503b Binary files /dev/null and b/80250154041d2e9f6d50a91181409f21.png differ diff --git a/82747b4bbd0cfe92292f74cd27f2763e.svg b/82747b4bbd0cfe92292f74cd27f2763e.svg new file mode 100644 index 0000000..8c9b3c7 --- /dev/null +++ b/82747b4bbd0cfe92292f74cd27f2763e.svg @@ -0,0 +1,13 @@ + + + + + + + + + diff --git a/86d4f1d7547270ff26f08a9271e7edcb.svg b/86d4f1d7547270ff26f08a9271e7edcb.svg new file mode 100644 index 0000000..ec5892d --- /dev/null +++ b/86d4f1d7547270ff26f08a9271e7edcb.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + diff --git a/8b61e99b17ef88afd479b3fc990e5b9d.xml b/8b61e99b17ef88afd479b3fc990e5b9d.xml new file mode 100644 index 0000000..6fa7ae5 --- /dev/null +++ b/8b61e99b17ef88afd479b3fc990e5b9d.xml @@ -0,0 +1,9 @@ + + + + + + #da532c + + + diff --git a/8f75583a16890ab851fc3f121fc63f89.svg b/8f75583a16890ab851fc3f121fc63f89.svg new file mode 100644 index 0000000..c462f75 --- /dev/null +++ b/8f75583a16890ab851fc3f121fc63f89.svg @@ -0,0 +1,16 @@ + + + + + + + + + diff --git a/9171288d67adc4805412883901d2f180.svg b/9171288d67adc4805412883901d2f180.svg new file mode 100644 index 0000000..8cf934f --- /dev/null +++ b/9171288d67adc4805412883901d2f180.svg @@ -0,0 +1,15 @@ + + + + + + + + + diff --git a/93a6487986f6662d71baf41fdeaf0196.png b/93a6487986f6662d71baf41fdeaf0196.png new file mode 100644 index 0000000..44b1482 Binary files /dev/null and b/93a6487986f6662d71baf41fdeaf0196.png differ diff --git a/972a0ac8cf8526580a216210a364cc60.svg b/972a0ac8cf8526580a216210a364cc60.svg new file mode 100644 index 0000000..56c90d1 --- /dev/null +++ b/972a0ac8cf8526580a216210a364cc60.svg @@ -0,0 +1,7 @@ + + + + + + diff --git a/9a1869e4318916bf5e05546eda8d5c43.css b/9a1869e4318916bf5e05546eda8d5c43.css new file mode 100644 index 0000000..9ee64c4 --- /dev/null +++ b/9a1869e4318916bf5e05546eda8d5c43.css @@ -0,0 +1,465 @@ +@charset "UTF-8"; +html, body { + background-color: #eee; + color: #000; + font-family: "Segoe UI", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif; + margin: 0; + overflow: hidden; + height: 100%; } + +#container { + height: 100%; } + +.channel-root-container { + text-size: 16px; + margin-left: 2px; + background-color: #fff; + border: 1px solid #d3d3d3; + float: left; + border-radius: 3px; + overflow-x: hidden; + overflow-y: auto; } + +.toolbar-horizontal ~ .channel-root-container { + margin-top: 2px; + width: calc(59% - 6px); + height: calc(98% - 38px); } + +.toolbar-vertical ~ .channel-root-container { + margin-top: 1%; + width: calc(59% - 6px); + height: calc(98% - 6px); } + +.chat { + margin-right: 2px; + float: left; } + +.toolbar-horizontal ~ .chat { + margin-top: 2px; + margin-left: 1%; + width: 39%; + height: calc(98% - 38px); } + +.toolbar-vertical ~ .chat { + margin-top: 1%; + margin-left: 2px; + width: calc(39% - 36px); + height: calc(98% - 4px); } + +.log { + background-color: #fff; + height: calc(100% - 42px); + padding: 5px; + border: 1px #d3d3d3 solid; + border-radius: 3px; + overflow-x: hidden; + overflow-y: scroll; } + +.branch img { + height: 19px; } + +.branch { + float: left; + padding-top: 3px; + padding-bottom: 3px; + background-color: #fff; } + +.channel-sub { + margin-left: 9px; + border-left: 1px transparent solid; + padding-left: 9px; } + +.channel-wrapper:nth-last-child(n + 2) > .branch:not(:empty) + .channel-sub { + border-left: 1px #d3d3d3 solid; } + +.channel-tree, +.user-wrapper { + margin-left: 9px; } + +.channel-tree, +.user-tree { + float: left; } + +.channel-tree::before, +.user-tree::before { + content: ""; + display: block; + position: relative; + width: 9px; + border-left: 1px #d3d3d3 solid; + border-bottom: 1px #d3d3d3 solid; + height: 14px; } + +.channel-wrapper:nth-last-child(n + 2) > .channel-tree:after, +.user-wrapper:nth-last-child(n + 2) .user-tree:after { + content: ""; + display: block; + position: relative; + width: 0px; + border-left: 1px #d3d3d3 solid; + height: 14px; } + +.user { + margin-left: 9px; } + +.user-avatar, .user-talk { + vertical-align: middle; } + +.user-avatar-talk-on { + filter: drop-shadow(1px 1px 1px green) drop-shadow(1px -1px 1px green) drop-shadow(-1px 1px 1px green) drop-shadow(-1px -1px 1px green); } + +.user-avatar-talk-whisper { + filter: drop-shadow(1px 1px 1px purple) drop-shadow(1px -1px 1px purple) drop-shadow(-1px 1px 1px purple) drop-shadow(-1px -1px 1px purple); } + +.user-avatar-talk-shout { + filter: drop-shadow(1px 1px 1px cyan) drop-shadow(1px -1px 1px cyan) drop-shadow(-1px 1px 1px cyan) drop-shadow(-1px -1px 1px cyan); } + +.user-status, .channel-status { + float: right; } + +.user, .channel { + height: 23px; + line-height: 23px; + padding: 2px; + border: 1px solid transparent; } + +.selected { + background-color: lightblue !important; + border: 1px solid #888; + border-radius: 3px; } + +.user:hover, .channel:hover { + background-color: #d3d3d3; } + +.thisClient { + font-weight: bold; } + +.currentChannel { + font-weight: bold; } + +.user-status img, .channel-status img { + margin-top: 2px; + width: 19px; + height: 19px; } + +.channel img, .user img { + width: auto; + height: 19px; } + +.channel-name, .user-name { + display: inline; } + +.channel:hover .tooltip, .user:hover .tooltip { + visibility: visible; + height: auto; + transition-delay: 1s; } + +.tooltip { + visibility: hidden; + height: 0px; + background: #fff; + border: 1px solid #888; + margin-top: 16px; + margin-left: 30px; + padding: 10px; + position: absolute; + z-index: 100; } + +.context-menu { + position: absolute; + z-index: 50; + background: #eee; + border: 1px solid #d3d3d3; + margin: 0; + padding: 0; + list-style: none; } + .context-menu > li { + padding: 5px 20px; + padding-left: 10px; } + .context-menu > li::before { + display: inline-block; + width: 10px; + padding-right: 5px; + content: ''; } + .context-menu > li.checked::before { + content: '\2713'; } + .context-menu > li:hover { + background: #d3d3d3; } + .context-menu > li.disabled { + background: #eee; + color: #a9a9a9; } + +.avatar-view { + position: absolute; + z-index: 200; + max-width: 90%; + max-height: 90%; + top: 0; + bottom: 0; + left: 0; + right: 0; + margin: auto; } + +.toolbar { + display: flex; + align-items: center; } + +.toolbar img { + height: 28px; + width: 28px; + padding: 2px; + border: 1px solid transparent; + border-radius: 3px; } + +.toolbar img:hover { + border: 1px solid #d3d3d3; + background-color: #a9a9a9; } + +.toolbar .tb-active { + border: 1px solid #fff; + background-color: #d3d3d3; } + +.toolbar-horizontal { + flex-direction: row; + height: 36px; + margin-top: 4px; + margin-left: 1%; + padding-left: 5px; } + +.toolbar-vertical { + flex-direction: column; + width: 36px; + margin-top: 1%; + margin-left: 4px; + padding-top: 5px; + float: left; } + +.toolbar-horizontal > * { + margin-right: 5px; } + +.toolbar-vertical > * { + margin-bottom: 5px; } + +.divider { + display: inline-block; } + +.toolbar-horizontal .divider { + height: 32px; + border-left: 1px #d3d3d3 solid; } + +.toolbar-vertical .divider { + width: 32px; + border-top: 1px #d3d3d3 solid; } + +.toolbar-horizontal .handle-horizontal { + width: auto !important; + border: none !important; + background-color: #eee !important; } + +.toolbar-horizontal .handle-vertical { + display: none; } + +.toolbar-vertical .handle-vertical { + height: auto !important; + border: none !important; + background-color: #eee !important; } + +.toolbar-vertical .handle-horizontal { + display: none; } + +.channel-icon .channel-icon-active { + display: none; } + +.channel-tag { + font-weight: bold; + color: orange; } + +.user-tag { + font-weight: bold; + color: green; } + +#message-box { + width: 100%; + border: none; + background: none; + color: #000; + margin: 5px 0 5px 0; + padding: 0; + height: 20px; } + +form { + margin: 0; + padding: 0; } + +.message-content p { + margin: 0; } + +.tb-information.disabled, .tb-record, .tb-comment { + filter: grayscale(100%); } + +.dialog-header { + height: 20px; + width: calc(100% - 10px); + padding: 5px; + text-align: center; + color: #fff; + background-color: #888; + border-bottom: 1px solid #a9a9a9; } + +.dialog-footer { + width: calc(100% - 20px); + margin: 10px; } + +.dialog-submit { + float: right; } + +.dialog-close, .dialog-submit { + width: 45%; + font-size: 15px; + border: 1px #888 solid; + border-radius: 3px; + background-color: #fff; + color: #000; + padding: 1px; } + +.connect-dialog table { + text-align: center; + width: 100%; } + +.dialog { + position: absolute; + max-height: calc(100% - 20px); + max-width: calc(100% - 20px); + top: 50%; + left: 50%; + transform: translate(-50%, -50%); + overflow: auto; + background-color: #eee; + color: #000; + border: 1px #888 solid; + box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.25); + z-index: 20; } + +.settings-dialog table { + width: 100%; + padding: 5px; } + +.settings-dialog td { + width: 50%; } + +.settings-dialog table select { + width: 100%; } + +.settings-dialog table input { + width: 100%; + margin: 0px; } + +.settings-dialog table input[type="checkbox"] { + width: auto; + margin: auto; } + +.settings-dialog .mic-volume-container { + height: 10px; + border: 3px solid #000; } + +.settings-dialog .mic-volume { + height: 100%; } + +.join-dialog { + width: 100%; + height: 100%; + top: 0px; + left: 0px; } + +.join-dialog .dialog-submit { + float: none; + width: 200px; + position: absolute; + top: calc(50% - 10px); + left: calc(50% - 100px); } + +.connect-dialog input[type=text], select { + font-size: 15px; + border: 1px #888 solid; + border-radius: 3px; + background-color: #fff; + color: #000; + padding: 2px; + width: calc(100% - 8px); } + +.connect-dialog input[type=password] { + font-size: 15px; + border: 1px #888 solid; + border-radius: 3px; + background-color: #fff; + color: #000; + padding: 2px; + width: calc(100% - 8px); } + +.connection-info-dialog h3 { + margin-bottom: 5px; } + +.connection-info-dialog .dialog-content { + padding-left: 20px; } + +/****************/ +/* Minimal view */ +/****************/ +.minimal .toolbar-horizontal ~ .channel-root-container { + width: calc(98% - 6px); } + +.minimal .toolbar-vertical ~ .channel-root-container { + width: calc(98% - 42px); } + +.minimal .handle-horizontal { + display: none; } + +.minimal .handle-vertical { + display: none; } + +.minimal .divider { + display: none; } + +.minimal .tb-connect { + display: none; } + +.minimal .tb-information { + display: none; } + +.minimal .tb-record { + display: none; } + +.minimal .tb-comment { + display: none; } + +.minimal .tb-settings { + display: none; } + +.minimal .tb-sourcecode { + display: none; } + +.minimal .chat { + display: none; } + +.minimal .channel-wrapper { + display: none; } + +.minimal .channel { + display: none; } + +.minimal .user-tree { + display: none; } + +.minimal .user-wrapper { + margin-left: 0px; } + +.minimal .user { + margin-left: 0px; + padding-top: 0px; + padding-bottom: 0px; + border: none; + height: 19px; + line-height: 19px; } + +.minimal .user-status { + height: 19px; } diff --git a/9ae3dac014f51d714254cf522602cec0.svg b/9ae3dac014f51d714254cf522602cec0.svg new file mode 100644 index 0000000..8e0a10f --- /dev/null +++ b/9ae3dac014f51d714254cf522602cec0.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/9cda20ca6e5077b6999771c9a8a3cec5.css b/9cda20ca6e5077b6999771c9a8a3cec5.css new file mode 100644 index 0000000..c3aee82 --- /dev/null +++ b/9cda20ca6e5077b6999771c9a8a3cec5.css @@ -0,0 +1,28 @@ +.loading-container { + position: absolute; + top: 0; + width: 100%; + height: 100%; + background-color: #eee; + z-index: 1000; } + +.loading-circle { + box-sizing: border-box; + width: 80px; + height: 80px; + position: absolute; + top: calc(50% - 40px); + left: calc(50% - 40px); + border-radius: 100%; + border: 10px solid #ddd; + border-top-color: #999; + animation: spin 1s infinite linear; } + +@keyframes spin { + 100% { + transform: rotate(360deg); } } + +.loaded { + top: -100%; + transition: top 1s; + transition-delay: 2s; } diff --git a/a65db861eecb8dcc62ad70fec489da3f.svg b/a65db861eecb8dcc62ad70fec489da3f.svg new file mode 100644 index 0000000..ed2fce5 --- /dev/null +++ b/a65db861eecb8dcc62ad70fec489da3f.svg @@ -0,0 +1,14 @@ + + + + + + + + diff --git a/b78ed441778f2e4ce1201a75af76594e.svg b/b78ed441778f2e4ce1201a75af76594e.svg new file mode 100644 index 0000000..40c6dd6 --- /dev/null +++ b/b78ed441778f2e4ce1201a75af76594e.svg @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/cf02aba975e911ef9823610d908b32f5.png b/cf02aba975e911ef9823610d908b32f5.png new file mode 100644 index 0000000..df4e45f Binary files /dev/null and b/cf02aba975e911ef9823610d908b32f5.png differ diff --git a/config.js b/config.js new file mode 100644 index 0000000..754d75c --- /dev/null +++ b/config.js @@ -0,0 +1,92 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports) { + + 'use strict'; + + // Note: You probably do not want to change any values in here because this + // file might need to be updated with new default values for new + // configuration options. Use the [config.local.js] file instead! + + window.mumbleWebConfig = { + // Which fields to show on the Connect to Server dialog + 'connectDialog': { + 'address': true, + 'port': true, + 'token': true, + 'username': true, + 'password': true, + 'channelName': false + }, + // Default values for user settings + // You can see your current value by typing `localStorage.getItem('mumble.$setting')` in the web console. + 'settings': { + 'voiceMode': 'vad', // one of 'cont' (Continuous), 'ptt' (Push-to-Talk), 'vad' (Voice Activity Detection) + 'pttKey': 'ctrl + shift', + 'vadLevel': 0.3, + 'toolbarVertical': false, + 'showAvatars': 'always', // one of 'always', 'own_channel', 'linked_channel', 'minimal_only', 'never' + 'userCountInChannelName': false, + 'audioBitrate': 40000, // bits per second + 'samplesPerPacket': 960 + }, + // Default values (can be changed by passing a query parameter of the same name) + 'defaults': { + // Connect Dialog + 'address': window.location.hostname, + 'port': '443', + 'token': '', + 'username': '', + 'password': '', + 'joinDialog': false, // replace whole dialog with single "Join Conference" button + 'matrix': false, // enable Matrix Widget support (mostly auto-detected; implies 'joinDialog') + 'avatarurl': '', // download and set the user's Mumble avatar to the image at this URL + // General + 'theme': 'MetroMumbleLight' + } + }; + +/***/ }) +/******/ ]); \ No newline at end of file diff --git a/config.local.js b/config.local.js new file mode 100644 index 0000000..aea8519 --- /dev/null +++ b/config.local.js @@ -0,0 +1,9 @@ +// You can overwrite the default configuration values set in [config.js] here. +// There should never be any required changes to this file and you can always +// simply copy it over when updating to a new version. + +let config = window.mumbleWebConfig // eslint-disable-line no-unused-vars + +// E.g. changing default address and theme: +// config.defaults.address = 'voice.example.com' +// config.defaults.theme = 'MetroMumbleDark' diff --git a/d57d3d2918d0b72f0c24e9dc162c6c4a.svg b/d57d3d2918d0b72f0c24e9dc162c6c4a.svg new file mode 100644 index 0000000..57fb6b0 --- /dev/null +++ b/d57d3d2918d0b72f0c24e9dc162c6c4a.svg @@ -0,0 +1,7 @@ + + + + + + diff --git a/d5ba30b381ebc262ba3871eaed9d7102.svg b/d5ba30b381ebc262ba3871eaed9d7102.svg new file mode 100644 index 0000000..8e22f09 --- /dev/null +++ b/d5ba30b381ebc262ba3871eaed9d7102.svg @@ -0,0 +1,15 @@ + + + + + + + + + + diff --git a/dbd9efebc73f884c5039cc3192a65dd8.svg b/dbd9efebc73f884c5039cc3192a65dd8.svg new file mode 100644 index 0000000..53eff05 --- /dev/null +++ b/dbd9efebc73f884c5039cc3192a65dd8.svg @@ -0,0 +1,13 @@ + + + + + + + + diff --git a/e0c171776518ab302b54ccc71e59a582.svg b/e0c171776518ab302b54ccc71e59a582.svg new file mode 100644 index 0000000..e0c7ccd --- /dev/null +++ b/e0c171776518ab302b54ccc71e59a582.svg @@ -0,0 +1,15 @@ + + + + + + + + + + diff --git a/e72996a6d1ed5d1d7962c27c10c08fa6.json b/e72996a6d1ed5d1d7962c27c10c08fa6.json new file mode 100644 index 0000000..a2f098e --- /dev/null +++ b/e72996a6d1ed5d1d7962c27c10c08fa6.json @@ -0,0 +1,17 @@ +{ + "name": "Mumble", + "icons": [ + { + "src": "5b70c2cbbd6e9258a632c70b03381627.png", + "sizes": "192x192", + "type": "image\/png" + }, + { + "src": "80250154041d2e9f6d50a91181409f21.png", + "sizes": "512x512", + "type": "image\/png" + } + ], + "theme_color": "#ffffff", + "display": "standalone" +} diff --git a/ec4d8b884ac39ef8494fb4aca6c6069f.svg b/ec4d8b884ac39ef8494fb4aca6c6069f.svg new file mode 100644 index 0000000..293f890 --- /dev/null +++ b/ec4d8b884ac39ef8494fb4aca6c6069f.svg @@ -0,0 +1,13 @@ + + + + + + + + diff --git a/ee7a19054eb87597c4b8e4664823ebfd.png b/ee7a19054eb87597c4b8e4664823ebfd.png new file mode 100644 index 0000000..83a08dd Binary files /dev/null and b/ee7a19054eb87597c4b8e4664823ebfd.png differ diff --git a/f2fc230fc7d9a9b8f6f03d342f6e94b2.svg b/f2fc230fc7d9a9b8f6f03d342f6e94b2.svg new file mode 100644 index 0000000..704a71b --- /dev/null +++ b/f2fc230fc7d9a9b8f6f03d342f6e94b2.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/f54b0be1d559b03ad8d945e988ec8ed4.svg b/f54b0be1d559b03ad8d945e988ec8ed4.svg new file mode 100644 index 0000000..b5e433a --- /dev/null +++ b/f54b0be1d559b03ad8d945e988ec8ed4.svg @@ -0,0 +1,16 @@ + + + + + + + + + diff --git a/index.html b/index.html new file mode 100644 index 0000000..5f84110 --- /dev/null +++ b/index.html @@ -0,0 +1,605 @@ + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ + + + diff --git a/index.js b/index.js new file mode 100644 index 0000000..790252d --- /dev/null +++ b/index.js @@ -0,0 +1,52941 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + __webpack_require__(39); + module.exports = __webpack_require__(343); + + +/***/ }), +/* 1 */, +/* 2 */, +/* 3 */, +/* 4 */, +/* 5 */, +/* 6 */, +/* 7 */, +/* 8 */, +/* 9 */, +/* 10 */, +/* 11 */, +/* 12 */, +/* 13 */, +/* 14 */, +/* 15 */, +/* 16 */, +/* 17 */, +/* 18 */, +/* 19 */, +/* 20 */, +/* 21 */, +/* 22 */, +/* 23 */, +/* 24 */, +/* 25 */, +/* 26 */, +/* 27 */, +/* 28 */, +/* 29 */, +/* 30 */, +/* 31 */, +/* 32 */, +/* 33 */, +/* 34 */, +/* 35 */, +/* 36 */, +/* 37 */, +/* 38 */, +/* 39 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + var _assign = __webpack_require__(40); + + var _assign2 = _interopRequireDefault(_assign); + + var _entries = __webpack_require__(78); + + var _entries2 = _interopRequireDefault(_entries); + + var _classCallCheck2 = __webpack_require__(82); + + var _classCallCheck3 = _interopRequireDefault(_classCallCheck2); + + var _createClass2 = __webpack_require__(83); + + var _createClass3 = _interopRequireDefault(_createClass2); + + __webpack_require__(87); + + __webpack_require__(117); + + var _url2 = __webpack_require__(118); + + var _url3 = _interopRequireDefault(_url2); + + var _bytebuffer = __webpack_require__(125); + + var _bytebuffer2 = _interopRequireDefault(_bytebuffer); + + var _mumbleClient = __webpack_require__(128); + + var _mumbleClient2 = _interopRequireDefault(_mumbleClient); + + var _workerClient = __webpack_require__(207); + + var _workerClient2 = _interopRequireDefault(_workerClient); + + var _webAudioBufferQueue = __webpack_require__(309); + + var _webAudioBufferQueue2 = _interopRequireDefault(_webAudioBufferQueue); + + var _audioContext = __webpack_require__(311); + + var _audioContext2 = _interopRequireDefault(_audioContext); + + var _knockout = __webpack_require__(312); + + var _knockout2 = _interopRequireDefault(_knockout); + + var _dompurify2 = __webpack_require__(313); + + var _dompurify3 = _interopRequireDefault(_dompurify2); + + var _keyboardjs = __webpack_require__(314); + + var _keyboardjs2 = _interopRequireDefault(_keyboardjs); + + var _voice = __webpack_require__(319); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + // polyfill for https://bugs.chromium.org/p/chromium/issues/detail?id=31666 + var dompurify = (0, _dompurify3.default)(window); // see https://github.com/ericgundrum/pouch-websocket-sync-example/commit/2a4437b013092cc7b2cd84cf1499172c84a963a3 + + + function sanitize(html) { + return dompurify.sanitize(html, { + ALLOWED_TAGS: ['br', 'b', 'i', 'u', 'a', 'span', 'p'] + }); + } + + function openContextMenu(event, contextMenu, target) { + contextMenu.posX(event.clientX); + contextMenu.posY(event.clientY); + contextMenu.target(target); + + var closeListener = function closeListener(event) { + // Always close, no matter where they clicked + setTimeout(function () { + // delay to allow click to be actually processed + contextMenu.target(null); + unregister(); + }); + }; + var unregister = function unregister() { + return document.removeEventListener('click', closeListener); + }; + document.addEventListener('click', closeListener); + + event.stopPropagation(); + event.preventDefault(); + } + + // GUI + + function ContextMenu() { + var self = this; + self.posX = _knockout2.default.observable(); + self.posY = _knockout2.default.observable(); + self.target = _knockout2.default.observable(); + } + + function ConnectDialog() { + var self = this; + self.address = _knockout2.default.observable(''); + self.port = _knockout2.default.observable(''); + self.tokenToAdd = _knockout2.default.observable(''); + self.selectedTokens = _knockout2.default.observableArray([]); + self.tokens = _knockout2.default.observableArray([]); + self.username = _knockout2.default.observable(''); + self.password = _knockout2.default.observable(''); + self.channelName = _knockout2.default.observable(''); + self.joinOnly = _knockout2.default.observable(false); + self.visible = _knockout2.default.observable(true); + self.show = self.visible.bind(self.visible, true); + self.hide = self.visible.bind(self.visible, false); + self.connect = function () { + self.hide(); + ui.connect(self.username(), self.address(), self.port(), self.tokens(), self.password(), self.channelName()); + }; + + self.addToken = function () { + if (self.tokenToAdd() != "" && self.tokens.indexOf(self.tokenToAdd()) < 0) { + self.tokens.push(self.tokenToAdd()); + } + self.tokenToAdd(""); + }; + + self.removeSelectedTokens = function () { + this.tokens.removeAll(this.selectedTokens()); + this.selectedTokens([]); + }; + } + + function ConnectErrorDialog(connectDialog) { + var self = this; + self.type = _knockout2.default.observable(0); + self.reason = _knockout2.default.observable(''); + self.username = connectDialog.username; + self.password = connectDialog.password; + self.joinOnly = connectDialog.joinOnly; + self.visible = _knockout2.default.observable(false); + self.show = self.visible.bind(self.visible, true); + self.hide = self.visible.bind(self.visible, false); + self.connect = function () { + self.hide(); + connectDialog.connect(); + }; + } + + var ConnectionInfo = function () { + function ConnectionInfo(ui) { + var _this = this; + + (0, _classCallCheck3.default)(this, ConnectionInfo); + + this._ui = ui; + this.visible = _knockout2.default.observable(false); + this.serverVersion = _knockout2.default.observable(); + this.latencyMs = _knockout2.default.observable(NaN); + this.latencyDeviation = _knockout2.default.observable(NaN); + this.remoteHost = _knockout2.default.observable(); + this.remotePort = _knockout2.default.observable(); + this.maxBitrate = _knockout2.default.observable(NaN); + this.currentBitrate = _knockout2.default.observable(NaN); + this.maxBandwidth = _knockout2.default.observable(NaN); + this.currentBandwidth = _knockout2.default.observable(NaN); + this.codec = _knockout2.default.observable(); + + this.show = function () { + if (!ui.thisUser()) return; + _this.update(); + _this.visible(true); + }; + this.hide = function () { + return _this.visible(false); + }; + } + + (0, _createClass3.default)(ConnectionInfo, [{ + key: 'update', + value: function update() { + var client = this._ui.client; + + this.serverVersion(client.serverVersion); + + var dataStats = client.dataStats; + if (dataStats) { + this.latencyMs(dataStats.mean); + this.latencyDeviation(Math.sqrt(dataStats.variance)); + } + this.remoteHost(this._ui.remoteHost()); + this.remotePort(this._ui.remotePort()); + + var spp = this._ui.settings.samplesPerPacket; + var maxBitrate = client.getMaxBitrate(spp, false); + var maxBandwidth = client.maxBandwidth; + var actualBitrate = client.getActualBitrate(spp, false); + var actualBandwidth = _mumbleClient2.default.calcEnforcableBandwidth(actualBitrate, spp, false); + this.maxBitrate(maxBitrate); + this.currentBitrate(actualBitrate); + this.maxBandwidth(maxBandwidth); + this.currentBandwidth(actualBandwidth); + this.codec('Opus'); // only one supported for sending + } + }]); + return ConnectionInfo; + }(); + + function CommentDialog() { + var self = this; + self.visible = _knockout2.default.observable(false); + self.show = function () { + self.visible(true); + }; + } + + var SettingsDialog = function () { + function SettingsDialog(settings) { + var _this2 = this; + + (0, _classCallCheck3.default)(this, SettingsDialog); + + this.voiceMode = _knockout2.default.observable(settings.voiceMode); + this.pttKey = _knockout2.default.observable(settings.pttKey); + this.pttKeyDisplay = _knockout2.default.observable(settings.pttKey); + this.vadLevel = _knockout2.default.observable(settings.vadLevel); + this.testVadLevel = _knockout2.default.observable(0); + this.testVadActive = _knockout2.default.observable(false); + this.showAvatars = _knockout2.default.observable(settings.showAvatars()); + this.userCountInChannelName = _knockout2.default.observable(settings.userCountInChannelName()); + // Need to wrap this in a pureComputed to make sure it's always numeric + var audioBitrate = _knockout2.default.observable(settings.audioBitrate); + this.audioBitrate = _knockout2.default.pureComputed({ + read: audioBitrate, + write: function write(value) { + return audioBitrate(Number(value)); + } + }); + this.samplesPerPacket = _knockout2.default.observable(settings.samplesPerPacket); + this.msPerPacket = _knockout2.default.pureComputed({ + read: function read() { + return _this2.samplesPerPacket() / 48; + }, + write: function write(value) { + return _this2.samplesPerPacket(value * 48); + } + }); + + this._setupTestVad(); + this.vadLevel.subscribe(function () { + return _this2._setupTestVad(); + }); + } + + (0, _createClass3.default)(SettingsDialog, [{ + key: '_setupTestVad', + value: function _setupTestVad() { + var _this3 = this; + + if (this._testVad) { + this._testVad.end(); + } + var dummySettings = new Settings({}); + this.applyTo(dummySettings); + this._testVad = new _voice.VADVoiceHandler(null, dummySettings); + this._testVad.on('started_talking', function () { + return _this3.testVadActive(true); + }).on('stopped_talking', function () { + return _this3.testVadActive(false); + }).on('level', function (level) { + return _this3.testVadLevel(level); + }); + testVoiceHandler = this._testVad; + } + }, { + key: 'applyTo', + value: function applyTo(settings) { + settings.voiceMode = this.voiceMode(); + settings.pttKey = this.pttKey(); + settings.vadLevel = this.vadLevel(); + settings.showAvatars(this.showAvatars()); + settings.userCountInChannelName(this.userCountInChannelName()); + settings.audioBitrate = this.audioBitrate(); + settings.samplesPerPacket = this.samplesPerPacket(); + } + }, { + key: 'end', + value: function end() { + this._testVad.end(); + testVoiceHandler = null; + } + }, { + key: 'recordPttKey', + value: function recordPttKey() { + var _this4 = this; + + var combo = []; + var keydown = function keydown(e) { + combo = e.pressedKeys; + var comboStr = combo.join(' + '); + _this4.pttKeyDisplay('> ' + comboStr + ' <'); + }; + var keyup = function keyup() { + _keyboardjs2.default.unbind('', keydown, keyup); + var comboStr = combo.join(' + '); + if (comboStr) { + _this4.pttKey(comboStr).pttKeyDisplay(comboStr); + } else { + _this4.pttKeyDisplay(_this4.pttKey()); + } + }; + _keyboardjs2.default.bind('', keydown, keyup); + this.pttKeyDisplay('> ? <'); + } + }, { + key: 'totalBandwidth', + value: function totalBandwidth() { + return _mumbleClient2.default.calcEnforcableBandwidth(this.audioBitrate(), this.samplesPerPacket(), true); + } + }, { + key: 'positionBandwidth', + value: function positionBandwidth() { + return this.totalBandwidth() - _mumbleClient2.default.calcEnforcableBandwidth(this.audioBitrate(), this.samplesPerPacket(), false); + } + }, { + key: 'overheadBandwidth', + value: function overheadBandwidth() { + return _mumbleClient2.default.calcEnforcableBandwidth(0, this.samplesPerPacket(), false); + } + }]); + return SettingsDialog; + }(); + + var Settings = function () { + function Settings(defaults) { + (0, _classCallCheck3.default)(this, Settings); + + var load = function load(key) { + return window.localStorage.getItem('mumble.' + key); + }; + this.voiceMode = load('voiceMode') || defaults.voiceMode; + this.pttKey = load('pttKey') || defaults.pttKey; + this.vadLevel = load('vadLevel') || defaults.vadLevel; + this.toolbarVertical = load('toolbarVertical') || defaults.toolbarVertical; + this.showAvatars = _knockout2.default.observable(load('showAvatars') || defaults.showAvatars); + this.userCountInChannelName = _knockout2.default.observable(load('userCountInChannelName') || defaults.userCountInChannelName); + this.audioBitrate = Number(load('audioBitrate')) || defaults.audioBitrate; + this.samplesPerPacket = Number(load('samplesPerPacket')) || defaults.samplesPerPacket; + } + + (0, _createClass3.default)(Settings, [{ + key: 'save', + value: function save() { + var save = function save(key, val) { + return window.localStorage.setItem('mumble.' + key, val); + }; + save('voiceMode', this.voiceMode); + save('pttKey', this.pttKey); + save('vadLevel', this.vadLevel); + save('toolbarVertical', this.toolbarVertical); + save('showAvatars', this.showAvatars()); + save('userCountInChannelName', this.userCountInChannelName()); + save('audioBitrate', this.audioBitrate); + save('samplesPerPacket', this.samplesPerPacket); + } + }]); + return Settings; + }(); + + var GlobalBindings = function GlobalBindings(config) { + var _this5 = this; + + (0, _classCallCheck3.default)(this, GlobalBindings); + + this.config = config; + this.settings = new Settings(config.settings); + this.connector = new _workerClient2.default(); + this.client = null; + this.userContextMenu = new ContextMenu(); + this.channelContextMenu = new ContextMenu(); + this.connectDialog = new ConnectDialog(); + this.connectErrorDialog = new ConnectErrorDialog(this.connectDialog); + this.connectionInfo = new ConnectionInfo(this); + this.commentDialog = new CommentDialog(); + this.settingsDialog = _knockout2.default.observable(); + this.minimalView = _knockout2.default.observable(false); + this.log = _knockout2.default.observableArray(); + this.remoteHost = _knockout2.default.observable(); + this.remotePort = _knockout2.default.observable(); + this.thisUser = _knockout2.default.observable(); + this.root = _knockout2.default.observable(); + this.avatarView = _knockout2.default.observable(); + this.messageBox = _knockout2.default.observable(''); + this.toolbarHorizontal = _knockout2.default.observable(!this.settings.toolbarVertical); + this.selected = _knockout2.default.observable(); + this.selfMute = _knockout2.default.observable(); + this.selfDeaf = _knockout2.default.observable(); + + this.selfMute.subscribe(function (mute) { + if (voiceHandler) { + voiceHandler.setMute(mute); + } + }); + + this.toggleToolbarOrientation = function () { + _this5.toolbarHorizontal(!_this5.toolbarHorizontal()); + _this5.settings.toolbarVertical = !_this5.toolbarHorizontal(); + _this5.settings.save(); + }; + + this.select = function (element) { + _this5.selected(element); + }; + + this.openSettings = function () { + _this5.settingsDialog(new SettingsDialog(_this5.settings)); + }; + + this.applySettings = function () { + var settingsDialog = _this5.settingsDialog(); + + settingsDialog.applyTo(_this5.settings); + + _this5._updateVoiceHandler(); + + _this5.settings.save(); + _this5.closeSettings(); + }; + + this.closeSettings = function () { + if (_this5.settingsDialog()) { + _this5.settingsDialog().end(); + } + _this5.settingsDialog(null); + }; + + this.getTimeString = function () { + return '[' + new Date().toLocaleTimeString('en-US') + ']'; + }; + + this.connect = function (username, host, port) { + var tokens = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []; + var password = arguments[4]; + var channelName = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : ""; + + _this5.resetClient(); + + _this5.remoteHost(host); + _this5.remotePort(port); + + log('Connecting to server ', host); + + // Note: This call needs to be delayed until the user has interacted with + // the page in some way (which at this point they have), see: https://goo.gl/7K7WLu + _this5.connector.setSampleRate((0, _audioContext2.default)().sampleRate); + + // TODO: token + _this5.connector.connect('wss://' + host + ':' + port, { + username: username, + password: password, + tokens: tokens + }).done(function (client) { + log('Connected!'); + + _this5.client = client; + // Prepare for connection errors + client.on('error', function (err) { + log('Connection error:', err); + _this5.resetClient(); + }); + + // Make sure we stay open if we're running as Matrix widget + window.matrixWidget.setAlwaysOnScreen(true); + + // Register all channels, recursively + if (channelName.indexOf("/") != 0) { + channelName = "/" + channelName; + } + var registerChannel = function registerChannel(channel, channelPath) { + _this5._newChannel(channel); + if (channelPath === channelName) { + client.self.setChannel(channel); + } + channel.children.forEach(function (ch) { + return registerChannel(ch, channelPath + "/" + ch.name); + }); + }; + registerChannel(client.root, ""); + + // Register all users + client.users.forEach(function (user) { + return _this5._newUser(user); + }); + + // Register future channels + client.on('newChannel', function (channel) { + return _this5._newChannel(channel); + }); + // Register future users + client.on('newUser', function (user) { + return _this5._newUser(user); + }); + + // Handle messages + client.on('message', function (sender, message, users, channels, trees) { + sender = sender || { __ui: 'Server' }; + ui.log.push({ + type: 'chat-message', + user: sender.__ui, + channel: channels.length > 0, + message: sanitize(message) + }); + }); + + // Set own user and root channel + _this5.thisUser(client.self.__ui); + _this5.root(client.root.__ui); + // Upate linked channels + _this5._updateLinks(); + // Log welcome message + if (client.welcomeMessage) { + _this5.log.push({ + type: 'welcome-message', + message: sanitize(client.welcomeMessage) + }); + } + + // Startup audio input processing + _this5._updateVoiceHandler(); + // Tell server our mute/deaf state (if necessary) + if (_this5.selfDeaf()) { + _this5.client.setSelfDeaf(true); + } else if (_this5.selfMute()) { + _this5.client.setSelfMute(true); + } + }, function (err) { + if (err.$type && err.$type.name === 'Reject') { + _this5.connectErrorDialog.type(err.type); + _this5.connectErrorDialog.reason(err.reason); + _this5.connectErrorDialog.show(); + } else { + log('Connection error:', err); + } + }); + }; + + this._newUser = function (user) { + var simpleProperties = { + uniqueId: 'uid', + username: 'name', + mute: 'mute', + deaf: 'deaf', + suppress: 'suppress', + selfMute: 'selfMute', + selfDeaf: 'selfDeaf', + texture: 'rawTexture', + textureHash: 'textureHash', + comment: 'comment' + }; + var ui = user.__ui = { + model: user, + talking: _knockout2.default.observable('off'), + channel: _knockout2.default.observable() + }; + ui.texture = _knockout2.default.pureComputed(function () { + var raw = ui.rawTexture(); + if (!raw || raw.offset >= raw.limit) return null; + return 'data:image/*;base64,' + _bytebuffer2.default.wrap(raw).toBase64(); + }); + ui.show_avatar = function () { + var setting = _this5.settings.showAvatars(); + switch (setting) { + case 'always': + break; + case 'own_channel': + if (_this5.thisUser().channel() !== ui.channel()) return false; + break; + case 'linked_channel': + if (!ui.channel().linked()) return false; + break; + case 'minimal_only': + if (!_this5.minimalView()) return false; + if (_this5.thisUser().channel() !== ui.channel()) return false; + break; + case 'never': + default: + return false; + } + if (!ui.texture()) { + if (ui.textureHash()) { + // The user has an avatar set but it's of sufficient size to not be + // included by default, so we need to fetch it explicitly now. + // mumble-client should make sure we only send one request per hash + user.requestTexture(); + } + return false; + } + return true; + }; + ui.openContextMenu = function (_, event) { + return openContextMenu(event, _this5.userContextMenu, ui); + }; + ui.canChangeMute = function () { + return false; // TODO check for perms and implement + }; + ui.canChangeDeafen = function () { + return false; // TODO check for perms and implement + }; + ui.canChangePrioritySpeaker = function () { + return false; // TODO check for perms and implement + }; + ui.canLocalMute = function () { + return false; // TODO implement local mute + // return this.thisUser() !== ui + }; + ui.canIgnoreMessages = function () { + return false; // TODO implement ignore messages + // return this.thisUser() !== ui + }; + ui.canChangeComment = function () { + return false; // TODO implement changing of comments + // return this.thisUser() === ui // TODO check for perms + }; + ui.canChangeAvatar = function () { + return _this5.thisUser() === ui; // TODO check for perms + }; + ui.toggleMute = function () { + if (ui.selfMute()) { + _this5.requestUnmute(ui); + } else { + _this5.requestMute(ui); + } + }; + ui.toggleDeaf = function () { + if (ui.selfDeaf()) { + _this5.requestUndeaf(ui); + } else { + _this5.requestDeaf(ui); + } + }; + ui.viewAvatar = function () { + _this5.avatarView(ui.texture()); + }; + ui.changeAvatar = function () { + var input = document.createElement('input'); + input.type = 'file'; + input.addEventListener('change', function () { + var reader = new window.FileReader(); + reader.onload = function () { + _this5.client.setSelfTexture(reader.result); + }; + reader.readAsArrayBuffer(input.files[0]); + }); + input.click(); + }; + ui.removeAvatar = function () { + user.clearTexture(); + }; + (0, _entries2.default)(simpleProperties).forEach(function (key) { + ui[key[1]] = _knockout2.default.observable(user[key[0]]); + }); + ui.state = _knockout2.default.pureComputed(userToState, ui); + if (user.channel) { + ui.channel(user.channel.__ui); + ui.channel().users.push(ui); + ui.channel().users.sort(compareUsers); + } + + user.on('update', function (actor, properties) { + (0, _entries2.default)(simpleProperties).forEach(function (key) { + if (properties[key[0]] !== undefined) { + ui[key[1]](properties[key[0]]); + } + }); + if (properties.channel !== undefined) { + if (ui.channel()) { + ui.channel().users.remove(ui); + } + ui.channel(properties.channel.__ui); + ui.channel().users.push(ui); + ui.channel().users.sort(compareUsers); + _this5._updateLinks(); + } + if (properties.textureHash !== undefined) { + // Invalidate avatar texture when its hash has changed + // If the avatar is still visible, this will trigger a fetch of the new one. + ui.rawTexture(null); + } + }).on('remove', function () { + if (ui.channel()) { + ui.channel().users.remove(ui); + } + }).on('voice', function (stream) { + console.log('User ' + user.username + ' started takling'); + var userNode = new _webAudioBufferQueue2.default({ + audioContext: (0, _audioContext2.default)() + }); + userNode.connect((0, _audioContext2.default)().destination); + + stream.on('data', function (data) { + if (data.target === 'normal') { + ui.talking('on'); + } else if (data.target === 'shout') { + ui.talking('shout'); + } else if (data.target === 'whisper') { + ui.talking('whisper'); + } + userNode.write(data.buffer); + }).on('end', function () { + console.log('User ' + user.username + ' stopped takling'); + ui.talking('off'); + userNode.end(); + }); + }); + }; + + this._newChannel = function (channel) { + var simpleProperties = { + position: 'position', + name: 'name', + description: 'description' + }; + var ui = channel.__ui = { + model: channel, + expanded: _knockout2.default.observable(true), + parent: _knockout2.default.observable(), + channels: _knockout2.default.observableArray(), + users: _knockout2.default.observableArray(), + linked: _knockout2.default.observable(false) + }; + ui.userCount = function () { + return ui.channels().reduce(function (acc, c) { + return acc + c.userCount(); + }, ui.users().length); + }; + ui.openContextMenu = function (_, event) { + return openContextMenu(event, _this5.channelContextMenu, ui); + }; + ui.canJoin = function () { + return true; // TODO check for perms + }; + ui.canAdd = function () { + return false; // TODO check for perms and implement + }; + ui.canEdit = function () { + return false; // TODO check for perms and implement + }; + ui.canRemove = function () { + return false; // TODO check for perms and implement + }; + ui.canLink = function () { + return false; // TODO check for perms and implement + }; + ui.canUnlink = function () { + return false; // TODO check for perms and implement + }; + ui.canSendMessage = function () { + return false; // TODO check for perms and implement + }; + (0, _entries2.default)(simpleProperties).forEach(function (key) { + ui[key[1]] = _knockout2.default.observable(channel[key[0]]); + }); + if (channel.parent) { + ui.parent(channel.parent.__ui); + ui.parent().channels.push(ui); + ui.parent().channels.sort(compareChannels); + } + _this5._updateLinks(); + + channel.on('update', function (properties) { + (0, _entries2.default)(simpleProperties).forEach(function (key) { + if (properties[key[0]] !== undefined) { + ui[key[1]](properties[key[0]]); + } + }); + if (properties.parent !== undefined) { + if (ui.parent()) { + ui.parent().channel.remove(ui); + } + ui.parent(properties.parent.__ui); + ui.parent().channels.push(ui); + ui.parent().channels.sort(compareChannels); + } + if (properties.links !== undefined) { + _this5._updateLinks(); + } + }).on('remove', function () { + if (ui.parent()) { + ui.parent().channels.remove(ui); + } + _this5._updateLinks(); + }); + }; + + this.resetClient = function () { + if (_this5.client) { + _this5.client.disconnect(); + } + _this5.client = null; + _this5.selected(null).root(null).thisUser(null); + }; + + this.connected = function () { + return _this5.thisUser() != null; + }; + + this._updateVoiceHandler = function () { + if (!_this5.client) { + return; + } + if (voiceHandler) { + voiceHandler.end(); + voiceHandler = null; + } + var mode = _this5.settings.voiceMode; + if (mode === 'cont') { + voiceHandler = new _voice.ContinuousVoiceHandler(_this5.client, _this5.settings); + } else if (mode === 'ptt') { + voiceHandler = new _voice.PushToTalkVoiceHandler(_this5.client, _this5.settings); + } else if (mode === 'vad') { + voiceHandler = new _voice.VADVoiceHandler(_this5.client, _this5.settings); + } else { + log('Unknown voice mode:', mode); + return; + } + voiceHandler.on('started_talking', function () { + if (_this5.thisUser()) { + _this5.thisUser().talking('on'); + } + }); + voiceHandler.on('stopped_talking', function () { + if (_this5.thisUser()) { + _this5.thisUser().talking('off'); + } + }); + if (_this5.selfMute()) { + voiceHandler.setMute(true); + } + + _this5.client.setAudioQuality(_this5.settings.audioBitrate, _this5.settings.samplesPerPacket); + }; + + this.messageBoxHint = _knockout2.default.pureComputed(function () { + if (!_this5.thisUser()) { + return ''; // Not yet connected + } + var target = _this5.selected(); + if (!target) { + target = _this5.thisUser(); + } + if (target === _this5.thisUser()) { + target = target.channel(); + } + if (target.users) { + // Channel + return "Type message to channel '" + target.name() + "' here"; + } else { + // User + return "Type message to user '" + target.name() + "' here"; + } + }); + + this.submitMessageBox = function () { + _this5.sendMessage(_this5.selected(), _this5.messageBox()); + _this5.messageBox(''); + }; + + this.sendMessage = function (target, message) { + if (_this5.connected()) { + // If no target is selected, choose our own user + if (!target) { + target = _this5.thisUser(); + } + // If target is our own user, send to our channel + if (target === _this5.thisUser()) { + target = target.channel(); + } + // Send message + target.model.sendMessage(message); + if (target.users) { + // Channel + _this5.log.push({ + type: 'chat-message-self', + message: sanitize(message), + channel: target + }); + } else { + // User + _this5.log.push({ + type: 'chat-message-self', + message: sanitize(message), + user: target + }); + } + } + }; + + this.requestMove = function (user, channel) { + if (_this5.connected()) { + user.model.setChannel(channel.model); + } + }; + + this.requestMute = function (user) { + if (user === _this5.thisUser()) { + _this5.selfMute(true); + } + if (_this5.connected()) { + if (user === _this5.thisUser()) { + _this5.client.setSelfMute(true); + } else { + user.model.setMute(true); + } + } + }; + + this.requestDeaf = function (user) { + if (user === _this5.thisUser()) { + _this5.selfMute(true); + _this5.selfDeaf(true); + } + if (_this5.connected()) { + if (user === _this5.thisUser()) { + _this5.client.setSelfDeaf(true); + } else { + user.model.setDeaf(true); + } + } + }; + + this.requestUnmute = function (user) { + if (user === _this5.thisUser()) { + _this5.selfMute(false); + _this5.selfDeaf(false); + } + if (_this5.connected()) { + if (user === _this5.thisUser()) { + _this5.client.setSelfMute(false); + } else { + user.model.setMute(false); + } + } + }; + + this.requestUndeaf = function (user) { + if (user === _this5.thisUser()) { + _this5.selfDeaf(false); + } + if (_this5.connected()) { + if (user === _this5.thisUser()) { + _this5.client.setSelfDeaf(false); + } else { + user.model.setDeaf(false); + } + } + }; + + this._updateLinks = function () { + if (!_this5.thisUser()) { + return; + } + + var allChannels = getAllChannels(_this5.root(), []); + var ownChannel = _this5.thisUser().channel().model; + var allLinked = findLinks(ownChannel, []); + allChannels.forEach(function (channel) { + channel.linked(allLinked.indexOf(channel.model) !== -1); + }); + + function findLinks(channel, knownLinks) { + knownLinks.push(channel); + channel.links.forEach(function (next) { + if (next && knownLinks.indexOf(next) === -1) { + findLinks(next, knownLinks); + } + }); + allChannels.map(function (c) { + return c.model; + }).forEach(function (next) { + if (next && knownLinks.indexOf(next) === -1 && next.links.indexOf(channel) !== -1) { + findLinks(next, knownLinks); + } + }); + return knownLinks; + } + + function getAllChannels(channel, channels) { + channels.push(channel); + channel.channels().forEach(function (next) { + return getAllChannels(next, channels); + }); + return channels; + } + }; + + this.openSourceCode = function () { + var homepage = __webpack_require__(342).homepage; + window.open(homepage, '_blank').focus(); + }; + + this.updateSize = function () { + _this5.minimalView(window.innerWidth < 320); + if (_this5.minimalView()) { + _this5.toolbarHorizontal(window.innerWidth < window.innerHeight); + } else { + _this5.toolbarHorizontal(!_this5.settings.toolbarVertical); + } + }; + }; + + var ui = new GlobalBindings(window.mumbleWebConfig); + + // Used only for debugging + window.mumbleUi = ui; + + window.onload = function () { + var queryParams = _url3.default.parse(document.location.href, true).query; + queryParams = (0, _assign2.default)({}, window.mumbleWebConfig.defaults, queryParams); + var useJoinDialog = queryParams.joinDialog; + if (queryParams.matrix) { + useJoinDialog = true; + } + if (queryParams.address) { + ui.connectDialog.address(queryParams.address); + } else { + useJoinDialog = false; + } + if (queryParams.port) { + ui.connectDialog.port(queryParams.port); + } else { + useJoinDialog = false; + } + if (queryParams.token) { + var tokens = queryParams.token; + if (!Array.isArray(tokens)) { + tokens = [tokens]; + } + ui.connectDialog.tokens(tokens); + } + if (queryParams.username) { + ui.connectDialog.username(queryParams.username); + } else { + useJoinDialog = false; + } + if (queryParams.password) { + ui.connectDialog.password(queryParams.password); + } + if (queryParams.channelName) { + ui.connectDialog.channelName(queryParams.channelName); + } + if (queryParams.avatarurl) { + // Download the avatar and upload it to the mumble server when connected + var _url = queryParams.avatarurl; + console.log('Fetching avatar from', _url); + var req = new window.XMLHttpRequest(); + req.open('GET', _url, true); + req.responseType = 'arraybuffer'; + req.onload = function () { + var upload = function upload(avatar) { + if (req.response) { + console.log('Uploading user avatar to server'); + ui.client.setSelfTexture(req.response); + } + }; + // On any future connections + ui.thisUser.subscribe(function (thisUser) { + if (thisUser) { + upload(); + } + }); + // And the current one (if already connected) + if (ui.thisUser()) { + upload(); + } + }; + req.send(); + } + ui.connectDialog.joinOnly(useJoinDialog); + _knockout2.default.applyBindings(ui); + }; + + window.onresize = function () { + return ui.updateSize(); + }; + ui.updateSize(); + + function log() { + console.log.apply(console, arguments); + var args = []; + for (var i = 0; i < arguments.length; i++) { + args.push(arguments[i]); + } + ui.log.push({ + type: 'generic', + value: args.join(' ') + }); + } + + function compareChannels(c1, c2) { + if (c1.position() === c2.position()) { + return c1.name() === c2.name() ? 0 : c1.name() < c2.name() ? -1 : 1; + } + return c1.position() - c2.position(); + } + + function compareUsers(u1, u2) { + return u1.name() === u2.name() ? 0 : u1.name() < u2.name() ? -1 : 1; + } + + function userToState() { + var flags = []; + // TODO: Friend + if (this.uid()) { + flags.push('Authenticated'); + } + // TODO: Priority Speaker, Recording + if (this.mute()) { + flags.push('Muted (server)'); + } + if (this.deaf()) { + flags.push('Deafened (server)'); + } + // TODO: Local Ignore (Text messages), Local Mute + if (this.selfMute()) { + flags.push('Muted (self)'); + } + if (this.selfDeaf()) { + flags.push('Deafened (self)'); + } + return flags.join(', '); + } + + var voiceHandler; + var testVoiceHandler; + + (0, _voice.initVoice)(function (data) { + if (testVoiceHandler) { + testVoiceHandler.write(data); + } + if (!ui.client) { + if (voiceHandler) { + voiceHandler.end(); + } + voiceHandler = null; + } else if (voiceHandler) { + voiceHandler.write(data); + } + }, function (err) { + log('Cannot initialize user media. Microphone will not work:', err); + }); + +/***/ }), +/* 40 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(41), __esModule: true }; + +/***/ }), +/* 41 */ +/***/ (function(module, exports, __webpack_require__) { + + __webpack_require__(42); + module.exports = __webpack_require__(45).Object.assign; + + +/***/ }), +/* 42 */ +/***/ (function(module, exports, __webpack_require__) { + + // 19.1.3.1 Object.assign(target, source) + var $export = __webpack_require__(43); + + $export($export.S + $export.F, 'Object', { assign: __webpack_require__(59) }); + + +/***/ }), +/* 43 */ +/***/ (function(module, exports, __webpack_require__) { + + var global = __webpack_require__(44); + var core = __webpack_require__(45); + var ctx = __webpack_require__(46); + var hide = __webpack_require__(48); + var has = __webpack_require__(58); + var PROTOTYPE = 'prototype'; + + var $export = function (type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var IS_WRAP = type & $export.W; + var exports = IS_GLOBAL ? core : core[name] || (core[name] = {}); + var expProto = exports[PROTOTYPE]; + var target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE]; + var key, own, out; + if (IS_GLOBAL) source = name; + for (key in source) { + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + if (own && has(exports, key)) continue; + // export native or passed + out = own ? target[key] : source[key]; + // prevent global pollution for namespaces + exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] + // bind timers to global for call from export context + : IS_BIND && own ? ctx(out, global) + // wrap global constructors for prevent change them in library + : IS_WRAP && target[key] == out ? (function (C) { + var F = function (a, b, c) { + if (this instanceof C) { + switch (arguments.length) { + case 0: return new C(); + case 1: return new C(a); + case 2: return new C(a, b); + } return new C(a, b, c); + } return C.apply(this, arguments); + }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + // make static versions for prototype methods + })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + // export proto methods to core.%CONSTRUCTOR%.methods.%NAME% + if (IS_PROTO) { + (exports.virtual || (exports.virtual = {}))[key] = out; + // export proto methods to core.%CONSTRUCTOR%.prototype.%NAME% + if (type & $export.R && expProto && !expProto[key]) hide(expProto, key, out); + } + } + }; + // type bitmap + $export.F = 1; // forced + $export.G = 2; // global + $export.S = 4; // static + $export.P = 8; // proto + $export.B = 16; // bind + $export.W = 32; // wrap + $export.U = 64; // safe + $export.R = 128; // real proto method for `library` + module.exports = $export; + + +/***/ }), +/* 44 */ +/***/ (function(module, exports) { + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self + // eslint-disable-next-line no-new-func + : Function('return this')(); + if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef + + +/***/ }), +/* 45 */ +/***/ (function(module, exports) { + + var core = module.exports = { version: '2.6.11' }; + if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef + + +/***/ }), +/* 46 */ +/***/ (function(module, exports, __webpack_require__) { + + // optional / simple context binding + var aFunction = __webpack_require__(47); + module.exports = function (fn, that, length) { + aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 1: return function (a) { + return fn.call(that, a); + }; + case 2: return function (a, b) { + return fn.call(that, a, b); + }; + case 3: return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + +/***/ }), +/* 47 */ +/***/ (function(module, exports) { + + module.exports = function (it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; + }; + + +/***/ }), +/* 48 */ +/***/ (function(module, exports, __webpack_require__) { + + var dP = __webpack_require__(49); + var createDesc = __webpack_require__(57); + module.exports = __webpack_require__(53) ? function (object, key, value) { + return dP.f(object, key, createDesc(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + +/***/ }), +/* 49 */ +/***/ (function(module, exports, __webpack_require__) { + + var anObject = __webpack_require__(50); + var IE8_DOM_DEFINE = __webpack_require__(52); + var toPrimitive = __webpack_require__(56); + var dP = Object.defineProperty; + + exports.f = __webpack_require__(53) ? Object.defineProperty : function defineProperty(O, P, Attributes) { + anObject(O); + P = toPrimitive(P, true); + anObject(Attributes); + if (IE8_DOM_DEFINE) try { + return dP(O, P, Attributes); + } catch (e) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + +/***/ }), +/* 50 */ +/***/ (function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(51); + module.exports = function (it) { + if (!isObject(it)) throw TypeError(it + ' is not an object!'); + return it; + }; + + +/***/ }), +/* 51 */ +/***/ (function(module, exports) { + + module.exports = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; + }; + + +/***/ }), +/* 52 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = !__webpack_require__(53) && !__webpack_require__(54)(function () { + return Object.defineProperty(__webpack_require__(55)('div'), 'a', { get: function () { return 7; } }).a != 7; + }); + + +/***/ }), +/* 53 */ +/***/ (function(module, exports, __webpack_require__) { + + // Thank's IE8 for his funny defineProperty + module.exports = !__webpack_require__(54)(function () { + return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; + }); + + +/***/ }), +/* 54 */ +/***/ (function(module, exports) { + + module.exports = function (exec) { + try { + return !!exec(); + } catch (e) { + return true; + } + }; + + +/***/ }), +/* 55 */ +/***/ (function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(51); + var document = __webpack_require__(44).document; + // typeof document.createElement is 'object' in old IE + var is = isObject(document) && isObject(document.createElement); + module.exports = function (it) { + return is ? document.createElement(it) : {}; + }; + + +/***/ }), +/* 56 */ +/***/ (function(module, exports, __webpack_require__) { + + // 7.1.1 ToPrimitive(input [, PreferredType]) + var isObject = __webpack_require__(51); + // instead of the ES6 spec version, we didn't implement @@toPrimitive case + // and the second argument - flag - preferred type is a string + module.exports = function (it, S) { + if (!isObject(it)) return it; + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val; + if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val; + throw TypeError("Can't convert object to primitive value"); + }; + + +/***/ }), +/* 57 */ +/***/ (function(module, exports) { + + module.exports = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + +/***/ }), +/* 58 */ +/***/ (function(module, exports) { + + var hasOwnProperty = {}.hasOwnProperty; + module.exports = function (it, key) { + return hasOwnProperty.call(it, key); + }; + + +/***/ }), +/* 59 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + // 19.1.2.1 Object.assign(target, source, ...) + var DESCRIPTORS = __webpack_require__(53); + var getKeys = __webpack_require__(60); + var gOPS = __webpack_require__(75); + var pIE = __webpack_require__(76); + var toObject = __webpack_require__(77); + var IObject = __webpack_require__(63); + var $assign = Object.assign; + + // should work with symbols and should have deterministic property order (V8 bug) + module.exports = !$assign || __webpack_require__(54)(function () { + var A = {}; + var B = {}; + // eslint-disable-next-line no-undef + var S = Symbol(); + var K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function (k) { B[k] = k; }); + return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars + var T = toObject(target); + var aLen = arguments.length; + var index = 1; + var getSymbols = gOPS.f; + var isEnum = pIE.f; + while (aLen > index) { + var S = IObject(arguments[index++]); + var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + +/***/ }), +/* 60 */ +/***/ (function(module, exports, __webpack_require__) { + + // 19.1.2.14 / 15.2.3.14 Object.keys(O) + var $keys = __webpack_require__(61); + var enumBugKeys = __webpack_require__(74); + + module.exports = Object.keys || function keys(O) { + return $keys(O, enumBugKeys); + }; + + +/***/ }), +/* 61 */ +/***/ (function(module, exports, __webpack_require__) { + + var has = __webpack_require__(58); + var toIObject = __webpack_require__(62); + var arrayIndexOf = __webpack_require__(66)(false); + var IE_PROTO = __webpack_require__(70)('IE_PROTO'); + + module.exports = function (object, names) { + var O = toIObject(object); + var i = 0; + var result = []; + var key; + for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key); + // Don't enum bug & hidden keys + while (names.length > i) if (has(O, key = names[i++])) { + ~arrayIndexOf(result, key) || result.push(key); + } + return result; + }; + + +/***/ }), +/* 62 */ +/***/ (function(module, exports, __webpack_require__) { + + // to indexed object, toObject with fallback for non-array-like ES3 strings + var IObject = __webpack_require__(63); + var defined = __webpack_require__(65); + module.exports = function (it) { + return IObject(defined(it)); + }; + + +/***/ }), +/* 63 */ +/***/ (function(module, exports, __webpack_require__) { + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var cof = __webpack_require__(64); + // eslint-disable-next-line no-prototype-builtins + module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) { + return cof(it) == 'String' ? it.split('') : Object(it); + }; + + +/***/ }), +/* 64 */ +/***/ (function(module, exports) { + + var toString = {}.toString; + + module.exports = function (it) { + return toString.call(it).slice(8, -1); + }; + + +/***/ }), +/* 65 */ +/***/ (function(module, exports) { + + // 7.2.1 RequireObjectCoercible(argument) + module.exports = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; + }; + + +/***/ }), +/* 66 */ +/***/ (function(module, exports, __webpack_require__) { + + // false -> Array#indexOf + // true -> Array#includes + var toIObject = __webpack_require__(62); + var toLength = __webpack_require__(67); + var toAbsoluteIndex = __webpack_require__(69); + module.exports = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIObject($this); + var length = toLength(O.length); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare + if (IS_INCLUDES && el != el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare + if (value != value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) if (IS_INCLUDES || index in O) { + if (O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + +/***/ }), +/* 67 */ +/***/ (function(module, exports, __webpack_require__) { + + // 7.1.15 ToLength + var toInteger = __webpack_require__(68); + var min = Math.min; + module.exports = function (it) { + return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991 + }; + + +/***/ }), +/* 68 */ +/***/ (function(module, exports) { + + // 7.1.4 ToInteger + var ceil = Math.ceil; + var floor = Math.floor; + module.exports = function (it) { + return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it); + }; + + +/***/ }), +/* 69 */ +/***/ (function(module, exports, __webpack_require__) { + + var toInteger = __webpack_require__(68); + var max = Math.max; + var min = Math.min; + module.exports = function (index, length) { + index = toInteger(index); + return index < 0 ? max(index + length, 0) : min(index, length); + }; + + +/***/ }), +/* 70 */ +/***/ (function(module, exports, __webpack_require__) { + + var shared = __webpack_require__(71)('keys'); + var uid = __webpack_require__(73); + module.exports = function (key) { + return shared[key] || (shared[key] = uid(key)); + }; + + +/***/ }), +/* 71 */ +/***/ (function(module, exports, __webpack_require__) { + + var core = __webpack_require__(45); + var global = __webpack_require__(44); + var SHARED = '__core-js_shared__'; + var store = global[SHARED] || (global[SHARED] = {}); + + (module.exports = function (key, value) { + return store[key] || (store[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: core.version, + mode: __webpack_require__(72) ? 'pure' : 'global', + copyright: '© 2019 Denis Pushkarev (zloirock.ru)' + }); + + +/***/ }), +/* 72 */ +/***/ (function(module, exports) { + + module.exports = true; + + +/***/ }), +/* 73 */ +/***/ (function(module, exports) { + + var id = 0; + var px = Math.random(); + module.exports = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); + }; + + +/***/ }), +/* 74 */ +/***/ (function(module, exports) { + + // IE 8- don't enum bug keys + module.exports = ( + 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf' + ).split(','); + + +/***/ }), +/* 75 */ +/***/ (function(module, exports) { + + exports.f = Object.getOwnPropertySymbols; + + +/***/ }), +/* 76 */ +/***/ (function(module, exports) { + + exports.f = {}.propertyIsEnumerable; + + +/***/ }), +/* 77 */ +/***/ (function(module, exports, __webpack_require__) { + + // 7.1.13 ToObject(argument) + var defined = __webpack_require__(65); + module.exports = function (it) { + return Object(defined(it)); + }; + + +/***/ }), +/* 78 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(79), __esModule: true }; + +/***/ }), +/* 79 */ +/***/ (function(module, exports, __webpack_require__) { + + __webpack_require__(80); + module.exports = __webpack_require__(45).Object.entries; + + +/***/ }), +/* 80 */ +/***/ (function(module, exports, __webpack_require__) { + + // https://github.com/tc39/proposal-object-values-entries + var $export = __webpack_require__(43); + var $entries = __webpack_require__(81)(true); + + $export($export.S, 'Object', { + entries: function entries(it) { + return $entries(it); + } + }); + + +/***/ }), +/* 81 */ +/***/ (function(module, exports, __webpack_require__) { + + var DESCRIPTORS = __webpack_require__(53); + var getKeys = __webpack_require__(60); + var toIObject = __webpack_require__(62); + var isEnum = __webpack_require__(76).f; + module.exports = function (isEntries) { + return function (it) { + var O = toIObject(it); + var keys = getKeys(O); + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS || isEnum.call(O, key)) { + result.push(isEntries ? [key, O[key]] : O[key]); + } + } + return result; + }; + }; + + +/***/ }), +/* 82 */ +/***/ (function(module, exports) { + + "use strict"; + + exports.__esModule = true; + + exports.default = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + +/***/ }), +/* 83 */ +/***/ (function(module, exports, __webpack_require__) { + + "use strict"; + + exports.__esModule = true; + + var _defineProperty = __webpack_require__(84); + + var _defineProperty2 = _interopRequireDefault(_defineProperty); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + + exports.default = function () { + function defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + (0, _defineProperty2.default)(target, descriptor.key, descriptor); + } + } + + return function (Constructor, protoProps, staticProps) { + if (protoProps) defineProperties(Constructor.prototype, protoProps); + if (staticProps) defineProperties(Constructor, staticProps); + return Constructor; + }; + }(); + +/***/ }), +/* 84 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(85), __esModule: true }; + +/***/ }), +/* 85 */ +/***/ (function(module, exports, __webpack_require__) { + + __webpack_require__(86); + var $Object = __webpack_require__(45).Object; + module.exports = function defineProperty(it, key, desc) { + return $Object.defineProperty(it, key, desc); + }; + + +/***/ }), +/* 86 */ +/***/ (function(module, exports, __webpack_require__) { + + var $export = __webpack_require__(43); + // 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes) + $export($export.S + $export.F * !__webpack_require__(53), 'Object', { defineProperty: __webpack_require__(49).f }); + + +/***/ }), +/* 87 */ +/***/ (function(module, exports, __webpack_require__) { + + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + module.exports = Stream; + + var EE = __webpack_require__(88).EventEmitter; + var inherits = __webpack_require__(89); + + inherits(Stream, EE); + Stream.Readable = __webpack_require__(90); + Stream.Writable = __webpack_require__(113); + Stream.Duplex = __webpack_require__(114); + Stream.Transform = __webpack_require__(115); + Stream.PassThrough = __webpack_require__(116); + + // Backwards-compat with node 0.4.x + Stream.Stream = Stream; + + + + // old-style streams. Note that the pipe method (the only relevant + // part of this class) is overridden in the Readable class. + + function Stream() { + EE.call(this); + } + + Stream.prototype.pipe = function(dest, options) { + var source = this; + + function ondata(chunk) { + if (dest.writable) { + if (false === dest.write(chunk) && source.pause) { + source.pause(); + } + } + } + + source.on('data', ondata); + + function ondrain() { + if (source.readable && source.resume) { + source.resume(); + } + } + + dest.on('drain', ondrain); + + // If the 'end' option is not supplied, dest.end() will be called when + // source gets the 'end' or 'close' events. Only dest.end() once. + if (!dest._isStdio && (!options || options.end !== false)) { + source.on('end', onend); + source.on('close', onclose); + } + + var didOnEnd = false; + function onend() { + if (didOnEnd) return; + didOnEnd = true; + + dest.end(); + } + + + function onclose() { + if (didOnEnd) return; + didOnEnd = true; + + if (typeof dest.destroy === 'function') dest.destroy(); + } + + // don't leave dangling pipes when there are errors. + function onerror(er) { + cleanup(); + if (EE.listenerCount(this, 'error') === 0) { + throw er; // Unhandled stream error in pipe. + } + } + + source.on('error', onerror); + dest.on('error', onerror); + + // remove all the event listeners that were added. + function cleanup() { + source.removeListener('data', ondata); + dest.removeListener('drain', ondrain); + + source.removeListener('end', onend); + source.removeListener('close', onclose); + + source.removeListener('error', onerror); + dest.removeListener('error', onerror); + + source.removeListener('end', cleanup); + source.removeListener('close', cleanup); + + dest.removeListener('close', cleanup); + } + + source.on('end', cleanup); + source.on('close', cleanup); + + dest.on('close', cleanup); + + dest.emit('pipe', source); + + // Allow for unix-like usage: A.pipe(B).pipe(C) + return dest; + }; + + +/***/ }), +/* 88 */ +/***/ (function(module, exports) { + + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + function EventEmitter() { + this._events = this._events || {}; + this._maxListeners = this._maxListeners || undefined; + } + module.exports = EventEmitter; + + // Backwards-compat with node 0.10.x + EventEmitter.EventEmitter = EventEmitter; + + EventEmitter.prototype._events = undefined; + EventEmitter.prototype._maxListeners = undefined; + + // By default EventEmitters will print a warning if more than 10 listeners are + // added to it. This is a useful default which helps finding memory leaks. + EventEmitter.defaultMaxListeners = 10; + + // Obviously not all Emitters should be limited to 10. This function allows + // that to be increased. Set to zero for unlimited. + EventEmitter.prototype.setMaxListeners = function(n) { + if (!isNumber(n) || n < 0 || isNaN(n)) + throw TypeError('n must be a positive number'); + this._maxListeners = n; + return this; + }; + + EventEmitter.prototype.emit = function(type) { + var er, handler, len, args, i, listeners; + + if (!this._events) + this._events = {}; + + // If there is no 'error' event listener then throw. + if (type === 'error') { + if (!this._events.error || + (isObject(this._events.error) && !this._events.error.length)) { + er = arguments[1]; + if (er instanceof Error) { + throw er; // Unhandled 'error' event + } else { + // At least give some kind of context to the user + var err = new Error('Uncaught, unspecified "error" event. (' + er + ')'); + err.context = er; + throw err; + } + } + } + + handler = this._events[type]; + + if (isUndefined(handler)) + return false; + + if (isFunction(handler)) { + switch (arguments.length) { + // fast cases + case 1: + handler.call(this); + break; + case 2: + handler.call(this, arguments[1]); + break; + case 3: + handler.call(this, arguments[1], arguments[2]); + break; + // slower + default: + args = Array.prototype.slice.call(arguments, 1); + handler.apply(this, args); + } + } else if (isObject(handler)) { + args = Array.prototype.slice.call(arguments, 1); + listeners = handler.slice(); + len = listeners.length; + for (i = 0; i < len; i++) + listeners[i].apply(this, args); + } + + return true; + }; + + EventEmitter.prototype.addListener = function(type, listener) { + var m; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events) + this._events = {}; + + // To avoid recursion in the case that type === "newListener"! Before + // adding it to the listeners, first emit "newListener". + if (this._events.newListener) + this.emit('newListener', type, + isFunction(listener.listener) ? + listener.listener : listener); + + if (!this._events[type]) + // Optimize the case of one listener. Don't need the extra array object. + this._events[type] = listener; + else if (isObject(this._events[type])) + // If we've already got an array, just append. + this._events[type].push(listener); + else + // Adding the second element, need to change to array. + this._events[type] = [this._events[type], listener]; + + // Check for listener leak + if (isObject(this._events[type]) && !this._events[type].warned) { + if (!isUndefined(this._maxListeners)) { + m = this._maxListeners; + } else { + m = EventEmitter.defaultMaxListeners; + } + + if (m && m > 0 && this._events[type].length > m) { + this._events[type].warned = true; + console.error('(node) warning: possible EventEmitter memory ' + + 'leak detected. %d listeners added. ' + + 'Use emitter.setMaxListeners() to increase limit.', + this._events[type].length); + if (typeof console.trace === 'function') { + // not supported in IE 10 + console.trace(); + } + } + } + + return this; + }; + + EventEmitter.prototype.on = EventEmitter.prototype.addListener; + + EventEmitter.prototype.once = function(type, listener) { + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + var fired = false; + + function g() { + this.removeListener(type, g); + + if (!fired) { + fired = true; + listener.apply(this, arguments); + } + } + + g.listener = listener; + this.on(type, g); + + return this; + }; + + // emits a 'removeListener' event iff the listener was removed + EventEmitter.prototype.removeListener = function(type, listener) { + var list, position, length, i; + + if (!isFunction(listener)) + throw TypeError('listener must be a function'); + + if (!this._events || !this._events[type]) + return this; + + list = this._events[type]; + length = list.length; + position = -1; + + if (list === listener || + (isFunction(list.listener) && list.listener === listener)) { + delete this._events[type]; + if (this._events.removeListener) + this.emit('removeListener', type, listener); + + } else if (isObject(list)) { + for (i = length; i-- > 0;) { + if (list[i] === listener || + (list[i].listener && list[i].listener === listener)) { + position = i; + break; + } + } + + if (position < 0) + return this; + + if (list.length === 1) { + list.length = 0; + delete this._events[type]; + } else { + list.splice(position, 1); + } + + if (this._events.removeListener) + this.emit('removeListener', type, listener); + } + + return this; + }; + + EventEmitter.prototype.removeAllListeners = function(type) { + var key, listeners; + + if (!this._events) + return this; + + // not listening for removeListener, no need to emit + if (!this._events.removeListener) { + if (arguments.length === 0) + this._events = {}; + else if (this._events[type]) + delete this._events[type]; + return this; + } + + // emit removeListener for all listeners on all events + if (arguments.length === 0) { + for (key in this._events) { + if (key === 'removeListener') continue; + this.removeAllListeners(key); + } + this.removeAllListeners('removeListener'); + this._events = {}; + return this; + } + + listeners = this._events[type]; + + if (isFunction(listeners)) { + this.removeListener(type, listeners); + } else if (listeners) { + // LIFO order + while (listeners.length) + this.removeListener(type, listeners[listeners.length - 1]); + } + delete this._events[type]; + + return this; + }; + + EventEmitter.prototype.listeners = function(type) { + var ret; + if (!this._events || !this._events[type]) + ret = []; + else if (isFunction(this._events[type])) + ret = [this._events[type]]; + else + ret = this._events[type].slice(); + return ret; + }; + + EventEmitter.prototype.listenerCount = function(type) { + if (this._events) { + var evlistener = this._events[type]; + + if (isFunction(evlistener)) + return 1; + else if (evlistener) + return evlistener.length; + } + return 0; + }; + + EventEmitter.listenerCount = function(emitter, type) { + return emitter.listenerCount(type); + }; + + function isFunction(arg) { + return typeof arg === 'function'; + } + + function isNumber(arg) { + return typeof arg === 'number'; + } + + function isObject(arg) { + return typeof arg === 'object' && arg !== null; + } + + function isUndefined(arg) { + return arg === void 0; + } + + +/***/ }), +/* 89 */ +/***/ (function(module, exports) { + + if (typeof Object.create === 'function') { + // implementation from standard node.js 'util' module + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }) + } + }; + } else { + // old school shim for old browsers + module.exports = function inherits(ctor, superCtor) { + if (superCtor) { + ctor.super_ = superCtor + var TempCtor = function () {} + TempCtor.prototype = superCtor.prototype + ctor.prototype = new TempCtor() + ctor.prototype.constructor = ctor + } + } + } + + +/***/ }), +/* 90 */ +/***/ (function(module, exports, __webpack_require__) { + + exports = module.exports = __webpack_require__(91); + exports.Stream = exports; + exports.Readable = exports; + exports.Writable = __webpack_require__(106); + exports.Duplex = __webpack_require__(105); + exports.Transform = __webpack_require__(111); + exports.PassThrough = __webpack_require__(112); + + +/***/ }), +/* 91 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + 'use strict'; + + /**/ + + var pna = __webpack_require__(93); + /**/ + + module.exports = Readable; + + /**/ + var isArray = __webpack_require__(94); + /**/ + + /**/ + var Duplex; + /**/ + + Readable.ReadableState = ReadableState; + + /**/ + var EE = __webpack_require__(88).EventEmitter; + + var EElistenerCount = function (emitter, type) { + return emitter.listeners(type).length; + }; + /**/ + + /**/ + var Stream = __webpack_require__(95); + /**/ + + /**/ + + var Buffer = __webpack_require__(96).Buffer; + var OurUint8Array = global.Uint8Array || function () {}; + function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); + } + function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; + } + + /**/ + + /**/ + var util = Object.create(__webpack_require__(100)); + util.inherits = __webpack_require__(89); + /**/ + + /**/ + var debugUtil = __webpack_require__(101); + var debug = void 0; + if (debugUtil && debugUtil.debuglog) { + debug = debugUtil.debuglog('stream'); + } else { + debug = function () {}; + } + /**/ + + var BufferList = __webpack_require__(102); + var destroyImpl = __webpack_require__(104); + var StringDecoder; + + util.inherits(Readable, Stream); + + var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume']; + + function prependListener(emitter, event, fn) { + // Sadly this is not cacheable as some libraries bundle their own + // event emitter implementation with them. + if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); + + // This is a hack to make sure that our error handler is attached before any + // userland ones. NEVER DO THIS. This is here only because this code needs + // to continue to work with older versions of Node.js that do not include + // the prependListener() method. The goal is to eventually remove this hack. + if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]]; + } + + function ReadableState(options, stream) { + Duplex = Duplex || __webpack_require__(105); + + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream. + // These options can be provided separately as readableXXX and writableXXX. + var isDuplex = stream instanceof Duplex; + + // object stream flag. Used to make read(n) ignore n and to + // make all the buffer merging and length checks go away + this.objectMode = !!options.objectMode; + + if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; + + // the point at which it stops calling _read() to fill the buffer + // Note: 0 is a valid value, means "don't call _read preemptively ever" + var hwm = options.highWaterMark; + var readableHwm = options.readableHighWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + + if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (readableHwm || readableHwm === 0)) this.highWaterMark = readableHwm;else this.highWaterMark = defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // A linked list is used to store data chunks instead of an array because the + // linked list can remove elements from the beginning faster than + // array.shift() + this.buffer = new BufferList(); + this.length = 0; + this.pipes = null; + this.pipesCount = 0; + this.flowing = null; + this.ended = false; + this.endEmitted = false; + this.reading = false; + + // a flag to be able to tell if the event 'readable'/'data' is emitted + // immediately, or on a later tick. We set this to true at first, because + // any actions that shouldn't happen until "later" should generally also + // not happen before the first read call. + this.sync = true; + + // whenever we return null, then we set a flag to say + // that we're awaiting a 'readable' event emission. + this.needReadable = false; + this.emittedReadable = false; + this.readableListening = false; + this.resumeScheduled = false; + + // has it been destroyed + this.destroyed = false; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // the number of writers that are awaiting a drain event in .pipe()s + this.awaitDrain = 0; + + // if true, a maybeReadMore has been scheduled + this.readingMore = false; + + this.decoder = null; + this.encoding = null; + if (options.encoding) { + if (!StringDecoder) StringDecoder = __webpack_require__(110).StringDecoder; + this.decoder = new StringDecoder(options.encoding); + this.encoding = options.encoding; + } + } + + function Readable(options) { + Duplex = Duplex || __webpack_require__(105); + + if (!(this instanceof Readable)) return new Readable(options); + + this._readableState = new ReadableState(options, this); + + // legacy + this.readable = true; + + if (options) { + if (typeof options.read === 'function') this._read = options.read; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + } + + Stream.call(this); + } + + Object.defineProperty(Readable.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined) { + return false; + } + return this._readableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._readableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + } + }); + + Readable.prototype.destroy = destroyImpl.destroy; + Readable.prototype._undestroy = destroyImpl.undestroy; + Readable.prototype._destroy = function (err, cb) { + this.push(null); + cb(err); + }; + + // Manually shove something into the read() buffer. + // This returns true if the highWaterMark has not been hit yet, + // similar to how Writable.write() returns true if you should + // write() some more. + Readable.prototype.push = function (chunk, encoding) { + var state = this._readableState; + var skipChunkCheck; + + if (!state.objectMode) { + if (typeof chunk === 'string') { + encoding = encoding || state.defaultEncoding; + if (encoding !== state.encoding) { + chunk = Buffer.from(chunk, encoding); + encoding = ''; + } + skipChunkCheck = true; + } + } else { + skipChunkCheck = true; + } + + return readableAddChunk(this, chunk, encoding, false, skipChunkCheck); + }; + + // Unshift should *always* be something directly out of read() + Readable.prototype.unshift = function (chunk) { + return readableAddChunk(this, chunk, null, true, false); + }; + + function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) { + var state = stream._readableState; + if (chunk === null) { + state.reading = false; + onEofChunk(stream, state); + } else { + var er; + if (!skipChunkCheck) er = chunkInvalid(state, chunk); + if (er) { + stream.emit('error', er); + } else if (state.objectMode || chunk && chunk.length > 0) { + if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (addToFront) { + if (state.endEmitted) stream.emit('error', new Error('stream.unshift() after end event'));else addChunk(stream, state, chunk, true); + } else if (state.ended) { + stream.emit('error', new Error('stream.push() after EOF')); + } else { + state.reading = false; + if (state.decoder && !encoding) { + chunk = state.decoder.write(chunk); + if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state); + } else { + addChunk(stream, state, chunk, false); + } + } + } else if (!addToFront) { + state.reading = false; + } + } + + return needMoreData(state); + } + + function addChunk(stream, state, chunk, addToFront) { + if (state.flowing && state.length === 0 && !state.sync) { + stream.emit('data', chunk); + stream.read(0); + } else { + // update the buffer info. + state.length += state.objectMode ? 1 : chunk.length; + if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk); + + if (state.needReadable) emitReadable(stream); + } + maybeReadMore(stream, state); + } + + function chunkInvalid(state, chunk) { + var er; + if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + return er; + } + + // if it's past the high water mark, we can push in some more. + // Also, if we have no data yet, we can stand some + // more bytes. This is to work around cases where hwm=0, + // such as the repl. Also, if the push() triggered a + // readable event, and the user called read(largeNumber) such that + // needReadable was set, then we ought to push more, so that another + // 'readable' event will be triggered. + function needMoreData(state) { + return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0); + } + + Readable.prototype.isPaused = function () { + return this._readableState.flowing === false; + }; + + // backwards compatibility. + Readable.prototype.setEncoding = function (enc) { + if (!StringDecoder) StringDecoder = __webpack_require__(110).StringDecoder; + this._readableState.decoder = new StringDecoder(enc); + this._readableState.encoding = enc; + return this; + }; + + // Don't raise the hwm > 8MB + var MAX_HWM = 0x800000; + function computeNewHighWaterMark(n) { + if (n >= MAX_HWM) { + n = MAX_HWM; + } else { + // Get the next highest power of 2 to prevent increasing hwm excessively in + // tiny amounts + n--; + n |= n >>> 1; + n |= n >>> 2; + n |= n >>> 4; + n |= n >>> 8; + n |= n >>> 16; + n++; + } + return n; + } + + // This function is designed to be inlinable, so please take care when making + // changes to the function body. + function howMuchToRead(n, state) { + if (n <= 0 || state.length === 0 && state.ended) return 0; + if (state.objectMode) return 1; + if (n !== n) { + // Only flow one buffer at a time + if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length; + } + // If we're asking for more than the current hwm, then raise the hwm. + if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n); + if (n <= state.length) return n; + // Don't have enough + if (!state.ended) { + state.needReadable = true; + return 0; + } + return state.length; + } + + // you can override either this method, or the async _read(n) below. + Readable.prototype.read = function (n) { + debug('read', n); + n = parseInt(n, 10); + var state = this._readableState; + var nOrig = n; + + if (n !== 0) state.emittedReadable = false; + + // if we're doing read(0) to trigger a readable event, but we + // already have a bunch of data in the buffer, then just trigger + // the 'readable' event and move on. + if (n === 0 && state.needReadable && (state.length >= state.highWaterMark || state.ended)) { + debug('read: emitReadable', state.length, state.ended); + if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this); + return null; + } + + n = howMuchToRead(n, state); + + // if we've ended, and we're now clear, then finish it up. + if (n === 0 && state.ended) { + if (state.length === 0) endReadable(this); + return null; + } + + // All the actual chunk generation logic needs to be + // *below* the call to _read. The reason is that in certain + // synthetic stream cases, such as passthrough streams, _read + // may be a completely synchronous operation which may change + // the state of the read buffer, providing enough data when + // before there was *not* enough. + // + // So, the steps are: + // 1. Figure out what the state of things will be after we do + // a read from the buffer. + // + // 2. If that resulting state will trigger a _read, then call _read. + // Note that this may be asynchronous, or synchronous. Yes, it is + // deeply ugly to write APIs this way, but that still doesn't mean + // that the Readable class should behave improperly, as streams are + // designed to be sync/async agnostic. + // Take note if the _read call is sync or async (ie, if the read call + // has returned yet), so that we know whether or not it's safe to emit + // 'readable' etc. + // + // 3. Actually pull the requested chunks out of the buffer and return. + + // if we need a readable event, then we need to do some reading. + var doRead = state.needReadable; + debug('need readable', doRead); + + // if we currently have less than the highWaterMark, then also read some + if (state.length === 0 || state.length - n < state.highWaterMark) { + doRead = true; + debug('length less than watermark', doRead); + } + + // however, if we've ended, then there's no point, and if we're already + // reading, then it's unnecessary. + if (state.ended || state.reading) { + doRead = false; + debug('reading or ended', doRead); + } else if (doRead) { + debug('do read'); + state.reading = true; + state.sync = true; + // if the length is currently zero, then we *need* a readable event. + if (state.length === 0) state.needReadable = true; + // call internal read method + this._read(state.highWaterMark); + state.sync = false; + // If _read pushed data synchronously, then `reading` will be false, + // and we need to re-evaluate how much data we can return to the user. + if (!state.reading) n = howMuchToRead(nOrig, state); + } + + var ret; + if (n > 0) ret = fromList(n, state);else ret = null; + + if (ret === null) { + state.needReadable = true; + n = 0; + } else { + state.length -= n; + } + + if (state.length === 0) { + // If we have nothing in the buffer, then we want to know + // as soon as we *do* get something into the buffer. + if (!state.ended) state.needReadable = true; + + // If we tried to read() past the EOF, then emit end on the next tick. + if (nOrig !== n && state.ended) endReadable(this); + } + + if (ret !== null) this.emit('data', ret); + + return ret; + }; + + function onEofChunk(stream, state) { + if (state.ended) return; + if (state.decoder) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) { + state.buffer.push(chunk); + state.length += state.objectMode ? 1 : chunk.length; + } + } + state.ended = true; + + // emit 'readable' now to make sure it gets picked up. + emitReadable(stream); + } + + // Don't emit readable right away in sync mode, because this can trigger + // another read() call => stack overflow. This way, it might trigger + // a nextTick recursion warning, but that's not so bad. + function emitReadable(stream) { + var state = stream._readableState; + state.needReadable = false; + if (!state.emittedReadable) { + debug('emitReadable', state.flowing); + state.emittedReadable = true; + if (state.sync) pna.nextTick(emitReadable_, stream);else emitReadable_(stream); + } + } + + function emitReadable_(stream) { + debug('emit readable'); + stream.emit('readable'); + flow(stream); + } + + // at this point, the user has presumably seen the 'readable' event, + // and called read() to consume some data. that may have triggered + // in turn another _read(n) call, in which case reading = true if + // it's in progress. + // However, if we're not ended, or reading, and the length < hwm, + // then go ahead and try to read some more preemptively. + function maybeReadMore(stream, state) { + if (!state.readingMore) { + state.readingMore = true; + pna.nextTick(maybeReadMore_, stream, state); + } + } + + function maybeReadMore_(stream, state) { + var len = state.length; + while (!state.reading && !state.flowing && !state.ended && state.length < state.highWaterMark) { + debug('maybeReadMore read 0'); + stream.read(0); + if (len === state.length) + // didn't get any data, stop spinning. + break;else len = state.length; + } + state.readingMore = false; + } + + // abstract method. to be overridden in specific implementation classes. + // call cb(er, data) where data is <= n in length. + // for virtual (non-string, non-buffer) streams, "length" is somewhat + // arbitrary, and perhaps not very meaningful. + Readable.prototype._read = function (n) { + this.emit('error', new Error('_read() is not implemented')); + }; + + Readable.prototype.pipe = function (dest, pipeOpts) { + var src = this; + var state = this._readableState; + + switch (state.pipesCount) { + case 0: + state.pipes = dest; + break; + case 1: + state.pipes = [state.pipes, dest]; + break; + default: + state.pipes.push(dest); + break; + } + state.pipesCount += 1; + debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts); + + var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr; + + var endFn = doEnd ? onend : unpipe; + if (state.endEmitted) pna.nextTick(endFn);else src.once('end', endFn); + + dest.on('unpipe', onunpipe); + function onunpipe(readable, unpipeInfo) { + debug('onunpipe'); + if (readable === src) { + if (unpipeInfo && unpipeInfo.hasUnpiped === false) { + unpipeInfo.hasUnpiped = true; + cleanup(); + } + } + } + + function onend() { + debug('onend'); + dest.end(); + } + + // when the dest drains, it reduces the awaitDrain counter + // on the source. This would be more elegant with a .once() + // handler in flow(), but adding and removing repeatedly is + // too slow. + var ondrain = pipeOnDrain(src); + dest.on('drain', ondrain); + + var cleanedUp = false; + function cleanup() { + debug('cleanup'); + // cleanup event handlers once the pipe is broken + dest.removeListener('close', onclose); + dest.removeListener('finish', onfinish); + dest.removeListener('drain', ondrain); + dest.removeListener('error', onerror); + dest.removeListener('unpipe', onunpipe); + src.removeListener('end', onend); + src.removeListener('end', unpipe); + src.removeListener('data', ondata); + + cleanedUp = true; + + // if the reader is waiting for a drain event from this + // specific writer, then it would cause it to never start + // flowing again. + // So, if this is awaiting a drain, then we just call it now. + // If we don't know, then assume that we are waiting for one. + if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain(); + } + + // If the user pushes more data while we're writing to dest then we'll end up + // in ondata again. However, we only want to increase awaitDrain once because + // dest will only emit one 'drain' event for the multiple writes. + // => Introduce a guard on increasing awaitDrain. + var increasedAwaitDrain = false; + src.on('data', ondata); + function ondata(chunk) { + debug('ondata'); + increasedAwaitDrain = false; + var ret = dest.write(chunk); + if (false === ret && !increasedAwaitDrain) { + // If the user unpiped during `dest.write()`, it is possible + // to get stuck in a permanently paused state if that write + // also returned false. + // => Check whether `dest` is still a piping destination. + if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) { + debug('false write response, pause', src._readableState.awaitDrain); + src._readableState.awaitDrain++; + increasedAwaitDrain = true; + } + src.pause(); + } + } + + // if the dest has an error, then stop piping into it. + // however, don't suppress the throwing behavior for this. + function onerror(er) { + debug('onerror', er); + unpipe(); + dest.removeListener('error', onerror); + if (EElistenerCount(dest, 'error') === 0) dest.emit('error', er); + } + + // Make sure our error handler is attached before userland ones. + prependListener(dest, 'error', onerror); + + // Both close and finish should trigger unpipe, but only once. + function onclose() { + dest.removeListener('finish', onfinish); + unpipe(); + } + dest.once('close', onclose); + function onfinish() { + debug('onfinish'); + dest.removeListener('close', onclose); + unpipe(); + } + dest.once('finish', onfinish); + + function unpipe() { + debug('unpipe'); + src.unpipe(dest); + } + + // tell the dest that it's being piped to + dest.emit('pipe', src); + + // start the flow if it hasn't been started already. + if (!state.flowing) { + debug('pipe resume'); + src.resume(); + } + + return dest; + }; + + function pipeOnDrain(src) { + return function () { + var state = src._readableState; + debug('pipeOnDrain', state.awaitDrain); + if (state.awaitDrain) state.awaitDrain--; + if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) { + state.flowing = true; + flow(src); + } + }; + } + + Readable.prototype.unpipe = function (dest) { + var state = this._readableState; + var unpipeInfo = { hasUnpiped: false }; + + // if we're not piping anywhere, then do nothing. + if (state.pipesCount === 0) return this; + + // just one destination. most common case. + if (state.pipesCount === 1) { + // passed in one, but it's not the right one. + if (dest && dest !== state.pipes) return this; + + if (!dest) dest = state.pipes; + + // got a match. + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + if (dest) dest.emit('unpipe', this, unpipeInfo); + return this; + } + + // slow case. multiple pipe destinations. + + if (!dest) { + // remove all. + var dests = state.pipes; + var len = state.pipesCount; + state.pipes = null; + state.pipesCount = 0; + state.flowing = false; + + for (var i = 0; i < len; i++) { + dests[i].emit('unpipe', this, unpipeInfo); + }return this; + } + + // try to find the right one. + var index = indexOf(state.pipes, dest); + if (index === -1) return this; + + state.pipes.splice(index, 1); + state.pipesCount -= 1; + if (state.pipesCount === 1) state.pipes = state.pipes[0]; + + dest.emit('unpipe', this, unpipeInfo); + + return this; + }; + + // set up data events if they are asked for + // Ensure readable listeners eventually get something + Readable.prototype.on = function (ev, fn) { + var res = Stream.prototype.on.call(this, ev, fn); + + if (ev === 'data') { + // Start flowing on next tick if stream isn't explicitly paused + if (this._readableState.flowing !== false) this.resume(); + } else if (ev === 'readable') { + var state = this._readableState; + if (!state.endEmitted && !state.readableListening) { + state.readableListening = state.needReadable = true; + state.emittedReadable = false; + if (!state.reading) { + pna.nextTick(nReadingNextTick, this); + } else if (state.length) { + emitReadable(this); + } + } + } + + return res; + }; + Readable.prototype.addListener = Readable.prototype.on; + + function nReadingNextTick(self) { + debug('readable nexttick read 0'); + self.read(0); + } + + // pause() and resume() are remnants of the legacy readable stream API + // If the user uses them, then switch into old mode. + Readable.prototype.resume = function () { + var state = this._readableState; + if (!state.flowing) { + debug('resume'); + state.flowing = true; + resume(this, state); + } + return this; + }; + + function resume(stream, state) { + if (!state.resumeScheduled) { + state.resumeScheduled = true; + pna.nextTick(resume_, stream, state); + } + } + + function resume_(stream, state) { + if (!state.reading) { + debug('resume read 0'); + stream.read(0); + } + + state.resumeScheduled = false; + state.awaitDrain = 0; + stream.emit('resume'); + flow(stream); + if (state.flowing && !state.reading) stream.read(0); + } + + Readable.prototype.pause = function () { + debug('call pause flowing=%j', this._readableState.flowing); + if (false !== this._readableState.flowing) { + debug('pause'); + this._readableState.flowing = false; + this.emit('pause'); + } + return this; + }; + + function flow(stream) { + var state = stream._readableState; + debug('flow', state.flowing); + while (state.flowing && stream.read() !== null) {} + } + + // wrap an old-style stream as the async data source. + // This is *not* part of the readable stream interface. + // It is an ugly unfortunate mess of history. + Readable.prototype.wrap = function (stream) { + var _this = this; + + var state = this._readableState; + var paused = false; + + stream.on('end', function () { + debug('wrapped end'); + if (state.decoder && !state.ended) { + var chunk = state.decoder.end(); + if (chunk && chunk.length) _this.push(chunk); + } + + _this.push(null); + }); + + stream.on('data', function (chunk) { + debug('wrapped data'); + if (state.decoder) chunk = state.decoder.write(chunk); + + // don't skip over falsy values in objectMode + if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return; + + var ret = _this.push(chunk); + if (!ret) { + paused = true; + stream.pause(); + } + }); + + // proxy all the other methods. + // important when wrapping filters and duplexes. + for (var i in stream) { + if (this[i] === undefined && typeof stream[i] === 'function') { + this[i] = function (method) { + return function () { + return stream[method].apply(stream, arguments); + }; + }(i); + } + } + + // proxy certain important events. + for (var n = 0; n < kProxyEvents.length; n++) { + stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n])); + } + + // when we try to consume some more bytes, simply unpause the + // underlying stream. + this._read = function (n) { + debug('wrapped _read', n); + if (paused) { + paused = false; + stream.resume(); + } + }; + + return this; + }; + + Object.defineProperty(Readable.prototype, 'readableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function () { + return this._readableState.highWaterMark; + } + }); + + // exposed for testing purposes only. + Readable._fromList = fromList; + + // Pluck off n bytes from an array of buffers. + // Length is the combined lengths of all the buffers in the list. + // This function is designed to be inlinable, so please take care when making + // changes to the function body. + function fromList(n, state) { + // nothing buffered + if (state.length === 0) return null; + + var ret; + if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) { + // read it all, truncate the list + if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.head.data;else ret = state.buffer.concat(state.length); + state.buffer.clear(); + } else { + // read part of list + ret = fromListPartial(n, state.buffer, state.decoder); + } + + return ret; + } + + // Extracts only enough buffered data to satisfy the amount requested. + // This function is designed to be inlinable, so please take care when making + // changes to the function body. + function fromListPartial(n, list, hasStrings) { + var ret; + if (n < list.head.data.length) { + // slice is the same for buffers and strings + ret = list.head.data.slice(0, n); + list.head.data = list.head.data.slice(n); + } else if (n === list.head.data.length) { + // first chunk is a perfect match + ret = list.shift(); + } else { + // result spans more than one buffer + ret = hasStrings ? copyFromBufferString(n, list) : copyFromBuffer(n, list); + } + return ret; + } + + // Copies a specified amount of characters from the list of buffered data + // chunks. + // This function is designed to be inlinable, so please take care when making + // changes to the function body. + function copyFromBufferString(n, list) { + var p = list.head; + var c = 1; + var ret = p.data; + n -= ret.length; + while (p = p.next) { + var str = p.data; + var nb = n > str.length ? str.length : n; + if (nb === str.length) ret += str;else ret += str.slice(0, n); + n -= nb; + if (n === 0) { + if (nb === str.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = str.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; + } + + // Copies a specified amount of bytes from the list of buffered data chunks. + // This function is designed to be inlinable, so please take care when making + // changes to the function body. + function copyFromBuffer(n, list) { + var ret = Buffer.allocUnsafe(n); + var p = list.head; + var c = 1; + p.data.copy(ret); + n -= p.data.length; + while (p = p.next) { + var buf = p.data; + var nb = n > buf.length ? buf.length : n; + buf.copy(ret, ret.length - n, 0, nb); + n -= nb; + if (n === 0) { + if (nb === buf.length) { + ++c; + if (p.next) list.head = p.next;else list.head = list.tail = null; + } else { + list.head = p; + p.data = buf.slice(nb); + } + break; + } + ++c; + } + list.length -= c; + return ret; + } + + function endReadable(stream) { + var state = stream._readableState; + + // If we get here before consuming all the bytes, then that is a + // bug in node. Should never happen. + if (state.length > 0) throw new Error('"endReadable()" called on non-empty stream'); + + if (!state.endEmitted) { + state.ended = true; + pna.nextTick(endReadableNT, state, stream); + } + } + + function endReadableNT(state, stream) { + // Check that we didn't get one last unshift. + if (!state.endEmitted && state.length === 0) { + state.endEmitted = true; + stream.readable = false; + stream.emit('end'); + } + } + + function indexOf(xs, x) { + for (var i = 0, l = xs.length; i < l; i++) { + if (xs[i] === x) return i; + } + return -1; + } + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(92))) + +/***/ }), +/* 92 */ +/***/ (function(module, exports) { + + // shim for using process in browser + var process = module.exports = {}; + + // cached from whatever global is present so that test runners that stub it + // don't break things. But we need to wrap it in a try catch in case it is + // wrapped in strict mode code which doesn't define any globals. It's inside a + // function because try/catches deoptimize in certain engines. + + var cachedSetTimeout; + var cachedClearTimeout; + + function defaultSetTimout() { + throw new Error('setTimeout has not been defined'); + } + function defaultClearTimeout () { + throw new Error('clearTimeout has not been defined'); + } + (function () { + try { + if (typeof setTimeout === 'function') { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === 'function') { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + } ()) + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + //normal enviroments in sane situations + return setTimeout(fun, 0); + } + // if setTimeout wasn't available but was latter defined + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedSetTimeout(fun, 0); + } catch(e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedSetTimeout.call(null, fun, 0); + } catch(e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error + return cachedSetTimeout.call(this, fun, 0); + } + } + + + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + //normal enviroments in sane situations + return clearTimeout(marker); + } + // if clearTimeout wasn't available but was latter defined + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + // when when somebody has screwed with setTimeout but no I.E. maddness + return cachedClearTimeout(marker); + } catch (e){ + try { + // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally + return cachedClearTimeout.call(null, marker); + } catch (e){ + // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error. + // Some versions of I.E. have different rules for clearTimeout vs setTimeout + return cachedClearTimeout.call(this, marker); + } + } + + + + } + var queue = []; + var draining = false; + var currentQueue; + var queueIndex = -1; + + function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } + } + + function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + + var len = queue.length; + while(len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); + } + + process.nextTick = function (fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } + }; + + // v8 likes predictible objects + function Item(fun, array) { + this.fun = fun; + this.array = array; + } + Item.prototype.run = function () { + this.fun.apply(null, this.array); + }; + process.title = 'browser'; + process.browser = true; + process.env = {}; + process.argv = []; + process.version = ''; // empty string to avoid regexp issues + process.versions = {}; + + function noop() {} + + process.on = noop; + process.addListener = noop; + process.once = noop; + process.off = noop; + process.removeListener = noop; + process.removeAllListeners = noop; + process.emit = noop; + process.prependListener = noop; + process.prependOnceListener = noop; + + process.listeners = function (name) { return [] } + + process.binding = function (name) { + throw new Error('process.binding is not supported'); + }; + + process.cwd = function () { return '/' }; + process.chdir = function (dir) { + throw new Error('process.chdir is not supported'); + }; + process.umask = function() { return 0; }; + + +/***/ }), +/* 93 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process) {'use strict'; + + if (typeof process === 'undefined' || + !process.version || + process.version.indexOf('v0.') === 0 || + process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) { + module.exports = { nextTick: nextTick }; + } else { + module.exports = process + } + + function nextTick(fn, arg1, arg2, arg3) { + if (typeof fn !== 'function') { + throw new TypeError('"callback" argument must be a function'); + } + var len = arguments.length; + var args, i; + switch (len) { + case 0: + case 1: + return process.nextTick(fn); + case 2: + return process.nextTick(function afterTickOne() { + fn.call(null, arg1); + }); + case 3: + return process.nextTick(function afterTickTwo() { + fn.call(null, arg1, arg2); + }); + case 4: + return process.nextTick(function afterTickThree() { + fn.call(null, arg1, arg2, arg3); + }); + default: + args = new Array(len - 1); + i = 0; + while (i < args.length) { + args[i++] = arguments[i]; + } + return process.nextTick(function afterTick() { + fn.apply(null, args); + }); + } + } + + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(92))) + +/***/ }), +/* 94 */ +/***/ (function(module, exports) { + + var toString = {}.toString; + + module.exports = Array.isArray || function (arr) { + return toString.call(arr) == '[object Array]'; + }; + + +/***/ }), +/* 95 */ +/***/ (function(module, exports, __webpack_require__) { + + module.exports = __webpack_require__(88).EventEmitter; + + +/***/ }), +/* 96 */ +/***/ (function(module, exports, __webpack_require__) { + + /* eslint-disable node/no-deprecated-api */ + var buffer = __webpack_require__(97) + var Buffer = buffer.Buffer + + // alternative to using Object.keys for old browsers + function copyProps (src, dst) { + for (var key in src) { + dst[key] = src[key] + } + } + if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) { + module.exports = buffer + } else { + // Copy properties from require('buffer') + copyProps(buffer, exports) + exports.Buffer = SafeBuffer + } + + function SafeBuffer (arg, encodingOrOffset, length) { + return Buffer(arg, encodingOrOffset, length) + } + + // Copy static methods from Buffer + copyProps(Buffer, SafeBuffer) + + SafeBuffer.from = function (arg, encodingOrOffset, length) { + if (typeof arg === 'number') { + throw new TypeError('Argument must not be a number') + } + return Buffer(arg, encodingOrOffset, length) + } + + SafeBuffer.alloc = function (size, fill, encoding) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + var buf = Buffer(size) + if (fill !== undefined) { + if (typeof encoding === 'string') { + buf.fill(fill, encoding) + } else { + buf.fill(fill) + } + } else { + buf.fill(0) + } + return buf + } + + SafeBuffer.allocUnsafe = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return Buffer(size) + } + + SafeBuffer.allocUnsafeSlow = function (size) { + if (typeof size !== 'number') { + throw new TypeError('Argument must be a number') + } + return buffer.SlowBuffer(size) + } + + +/***/ }), +/* 97 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + /* eslint-disable no-proto */ + + 'use strict' + + var base64 = __webpack_require__(98) + var ieee754 = __webpack_require__(99) + var isArray = __webpack_require__(94) + + exports.Buffer = Buffer + exports.SlowBuffer = SlowBuffer + exports.INSPECT_MAX_BYTES = 50 + + /** + * If `Buffer.TYPED_ARRAY_SUPPORT`: + * === true Use Uint8Array implementation (fastest) + * === false Use 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+. + * + * Due to various browser bugs, sometimes the Object implementation will be used even + * when the browser supports typed arrays. + * + * Note: + * + * - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances, + * See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438. + * + * - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function. + * + * - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of + * incorrect length in some situations. + + * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they + * get the Object implementation, which is slower but behaves correctly. + */ + Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined + ? global.TYPED_ARRAY_SUPPORT + : typedArraySupport() + + /* + * Export kMaxLength after typed array support is determined. + */ + exports.kMaxLength = kMaxLength() + + function typedArraySupport () { + try { + var arr = new Uint8Array(1) + arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }} + return arr.foo() === 42 && // typed array instances can be augmented + typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray` + arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray` + } catch (e) { + return false + } + } + + function kMaxLength () { + return Buffer.TYPED_ARRAY_SUPPORT + ? 0x7fffffff + : 0x3fffffff + } + + function createBuffer (that, length) { + if (kMaxLength() < length) { + throw new RangeError('Invalid typed array length') + } + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = new Uint8Array(length) + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + if (that === null) { + that = new Buffer(length) + } + that.length = length + } + + return that + } + + /** + * 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) { + if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) { + return new Buffer(arg, encodingOrOffset, length) + } + + // Common case. + if (typeof arg === 'number') { + if (typeof encodingOrOffset === 'string') { + throw new Error( + 'If encoding is specified then the first argument must be a string' + ) + } + return allocUnsafe(this, arg) + } + return from(this, arg, encodingOrOffset, length) + } + + Buffer.poolSize = 8192 // not used by this implementation + + // TODO: Legacy, not needed anymore. Remove in next major version. + Buffer._augment = function (arr) { + arr.__proto__ = Buffer.prototype + return arr + } + + function from (that, value, encodingOrOffset, length) { + if (typeof value === 'number') { + throw new TypeError('"value" argument must not be a number') + } + + if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) { + return fromArrayBuffer(that, value, encodingOrOffset, length) + } + + if (typeof value === 'string') { + return fromString(that, value, encodingOrOffset) + } + + return fromObject(that, 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(null, value, encodingOrOffset, length) + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + Buffer.prototype.__proto__ = Uint8Array.prototype + Buffer.__proto__ = Uint8Array + if (typeof Symbol !== 'undefined' && Symbol.species && + Buffer[Symbol.species] === Buffer) { + // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97 + Object.defineProperty(Buffer, Symbol.species, { + value: null, + configurable: true + }) + } + } + + function assertSize (size) { + if (typeof size !== 'number') { + throw new TypeError('"size" argument must be a number') + } else if (size < 0) { + throw new RangeError('"size" argument must not be negative') + } + } + + function alloc (that, size, fill, encoding) { + assertSize(size) + if (size <= 0) { + return createBuffer(that, 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(that, size).fill(fill, encoding) + : createBuffer(that, size).fill(fill) + } + return createBuffer(that, size) + } + + /** + * Creates a new filled Buffer instance. + * alloc(size[, fill[, encoding]]) + **/ + Buffer.alloc = function (size, fill, encoding) { + return alloc(null, size, fill, encoding) + } + + function allocUnsafe (that, size) { + assertSize(size) + that = createBuffer(that, size < 0 ? 0 : checked(size) | 0) + if (!Buffer.TYPED_ARRAY_SUPPORT) { + for (var i = 0; i < size; ++i) { + that[i] = 0 + } + } + return that + } + + /** + * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance. + * */ + Buffer.allocUnsafe = function (size) { + return allocUnsafe(null, size) + } + /** + * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance. + */ + Buffer.allocUnsafeSlow = function (size) { + return allocUnsafe(null, size) + } + + function fromString (that, string, encoding) { + if (typeof encoding !== 'string' || encoding === '') { + encoding = 'utf8' + } + + if (!Buffer.isEncoding(encoding)) { + throw new TypeError('"encoding" must be a valid string encoding') + } + + var length = byteLength(string, encoding) | 0 + that = createBuffer(that, length) + + var actual = that.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') + that = that.slice(0, actual) + } + + return that + } + + function fromArrayLike (that, array) { + var length = array.length < 0 ? 0 : checked(array.length) | 0 + that = createBuffer(that, length) + for (var i = 0; i < length; i += 1) { + that[i] = array[i] & 255 + } + return that + } + + function fromArrayBuffer (that, array, byteOffset, length) { + array.byteLength // this throws if `array` is not a valid ArrayBuffer + + if (byteOffset < 0 || array.byteLength < byteOffset) { + throw new RangeError('\'offset\' is out of bounds') + } + + if (array.byteLength < byteOffset + (length || 0)) { + throw new RangeError('\'length\' is out of bounds') + } + + if (byteOffset === undefined && length === undefined) { + array = new Uint8Array(array) + } else if (length === undefined) { + array = new Uint8Array(array, byteOffset) + } else { + array = new Uint8Array(array, byteOffset, length) + } + + if (Buffer.TYPED_ARRAY_SUPPORT) { + // Return an augmented `Uint8Array` instance, for best performance + that = array + that.__proto__ = Buffer.prototype + } else { + // Fallback: Return an object instance of the Buffer class + that = fromArrayLike(that, array) + } + return that + } + + function fromObject (that, obj) { + if (Buffer.isBuffer(obj)) { + var len = checked(obj.length) | 0 + that = createBuffer(that, len) + + if (that.length === 0) { + return that + } + + obj.copy(that, 0, 0, len) + return that + } + + if (obj) { + if ((typeof ArrayBuffer !== 'undefined' && + obj.buffer instanceof ArrayBuffer) || 'length' in obj) { + if (typeof obj.length !== 'number' || isnan(obj.length)) { + return createBuffer(that, 0) + } + return fromArrayLike(that, obj) + } + + if (obj.type === 'Buffer' && isArray(obj.data)) { + return fromArrayLike(that, obj.data) + } + } + + throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.') + } + + function checked (length) { + // Note: cannot use `length < kMaxLength()` here because that fails when + // length is NaN (which is otherwise coerced to zero.) + if (length >= kMaxLength()) { + throw new RangeError('Attempt to allocate Buffer larger than maximum ' + + 'size: 0x' + kMaxLength().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) + } + + Buffer.compare = function compare (a, b) { + if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) { + throw new TypeError('Arguments must be Buffers') + } + + 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 (!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 (!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 (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' && + (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) { + return string.byteLength + } + if (typeof string !== 'string') { + string = '' + string + } + + var len = string.length + if (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': + case undefined: + 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 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 + } + } + } + + // The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect + // Buffer instances. + 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 | 0 + if (length === 0) return '' + if (arguments.length === 0) return utf8Slice(this, 0, length) + return slowToString.apply(this, arguments) + } + + 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 + if (this.length > 0) { + str = this.toString('hex', 0, max).match(/.{2}/g).join(' ') + if (this.length > max) str += ' ... ' + } + return '' + } + + Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) { + if (!Buffer.isBuffer(target)) { + throw new TypeError('Argument must be a Buffer') + } + + 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 (isNaN(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 (Buffer.TYPED_ARRAY_SUPPORT && + 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 + } + } + + // must be an even number of digits + var strLen = string.length + if (strLen % 2 !== 0) throw new TypeError('Invalid hex string') + + if (length > strLen / 2) { + length = strLen / 2 + } + for (var i = 0; i < length; ++i) { + var parsed = parseInt(string.substr(i * 2, 2), 16) + if (isNaN(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 + } + // legacy write(string, encoding, offset, length) - remove in v0.13 + } 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 + if (Buffer.TYPED_ARRAY_SUPPORT) { + newBuf = this.subarray(start, end) + newBuf.__proto__ = Buffer.prototype + } else { + var sliceLen = end - start + newBuf = new Buffer(sliceLen, undefined) + for (var i = 0; i < sliceLen; ++i) { + newBuf[i] = this[i + start] + } + } + + 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) { + if (!noAssert) checkOffset(offset, 1, this.length) + return this[offset] + } + + Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return this[offset] | (this[offset + 1] << 8) + } + + Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 2, this.length) + return (this[offset] << 8) | this[offset + 1] + } + + Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, true, 23, 4) + } + + Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 4, this.length) + return ieee754.read(this, offset, false, 23, 4) + } + + Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) { + if (!noAssert) checkOffset(offset, 8, this.length) + return ieee754.read(this, offset, true, 52, 8) + } + + Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) { + 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) + if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + this[offset] = (value & 0xff) + return offset + 1 + } + + function objectWriteUInt16 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) { + buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>> + (littleEndian ? i : 1 - i) * 8 + } + } + + Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + return offset + 2 + } + + function objectWriteUInt32 (buf, value, offset, littleEndian) { + if (value < 0) value = 0xffffffff + value + 1 + for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) { + buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff + } + } + + Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) { + value = +value + offset = offset | 0 + if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset + 3] = (value >>> 24) + this[offset + 2] = (value >>> 16) + this[offset + 1] = (value >>> 8) + this[offset] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + 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 (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value) + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + } else { + objectWriteUInt16(this, value, offset, true) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 8) + this[offset + 1] = (value & 0xff) + } else { + objectWriteUInt16(this, value, offset, false) + } + 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) + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value & 0xff) + this[offset + 1] = (value >>> 8) + this[offset + 2] = (value >>> 16) + this[offset + 3] = (value >>> 24) + } else { + objectWriteUInt32(this, value, offset, true) + } + 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 + if (Buffer.TYPED_ARRAY_SUPPORT) { + this[offset] = (value >>> 24) + this[offset + 1] = (value >>> 16) + this[offset + 2] = (value >>> 8) + this[offset + 3] = (value & 0xff) + } else { + objectWriteUInt32(this, value, offset, false) + } + 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) { + 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) { + 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 (!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('sourceStart out of bounds') + 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 + var i + + if (this === target && start < targetStart && targetStart < end) { + // descending copy from end + for (i = len - 1; i >= 0; --i) { + target[i + targetStart] = this[i + start] + } + } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) { + // ascending copy from start + for (i = 0; i < len; ++i) { + target[i + targetStart] = this[i + start] + } + } else { + Uint8Array.prototype.set.call( + target, + this.subarray(start, start + len), + 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 (val.length === 1) { + var code = val.charCodeAt(0) + if (code < 256) { + val = code + } + } + 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) + } + } 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 + : utf8ToBytes(new Buffer(val, encoding).toString()) + var len = bytes.length + 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 strips out invalid characters like \n and \t from the string, base64-js does not + str = stringtrim(str).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 stringtrim (str) { + if (str.trim) return str.trim() + return str.replace(/^\s+|\s+$/g, '') + } + + 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 + } + + function isnan (val) { + return val !== val // eslint-disable-line no-self-compare + } + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }), +/* 98 */ +/***/ (function(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('') + } + + +/***/ }), +/* 99 */ +/***/ (function(module, exports) { + + 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 + } + + +/***/ }), +/* 100 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(Buffer) {// Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + // NOTE: These type checking functions intentionally don't use `instanceof` + // because it is fragile and can be easily faked with `Object.create()`. + + function isArray(arg) { + if (Array.isArray) { + return Array.isArray(arg); + } + return objectToString(arg) === '[object Array]'; + } + exports.isArray = isArray; + + function isBoolean(arg) { + return typeof arg === 'boolean'; + } + exports.isBoolean = isBoolean; + + function isNull(arg) { + return arg === null; + } + exports.isNull = isNull; + + function isNullOrUndefined(arg) { + return arg == null; + } + exports.isNullOrUndefined = isNullOrUndefined; + + function isNumber(arg) { + return typeof arg === 'number'; + } + exports.isNumber = isNumber; + + function isString(arg) { + return typeof arg === 'string'; + } + exports.isString = isString; + + function isSymbol(arg) { + return typeof arg === 'symbol'; + } + exports.isSymbol = isSymbol; + + function isUndefined(arg) { + return arg === void 0; + } + exports.isUndefined = isUndefined; + + function isRegExp(re) { + return objectToString(re) === '[object RegExp]'; + } + exports.isRegExp = isRegExp; + + function isObject(arg) { + return typeof arg === 'object' && arg !== null; + } + exports.isObject = isObject; + + function isDate(d) { + return objectToString(d) === '[object Date]'; + } + exports.isDate = isDate; + + function isError(e) { + return (objectToString(e) === '[object Error]' || e instanceof Error); + } + exports.isError = isError; + + function isFunction(arg) { + return typeof arg === 'function'; + } + exports.isFunction = isFunction; + + function isPrimitive(arg) { + return arg === null || + typeof arg === 'boolean' || + typeof arg === 'number' || + typeof arg === 'string' || + typeof arg === 'symbol' || // ES6 symbol + typeof arg === 'undefined'; + } + exports.isPrimitive = isPrimitive; + + exports.isBuffer = Buffer.isBuffer; + + function objectToString(o) { + return Object.prototype.toString.call(o); + } + + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(97).Buffer)) + +/***/ }), +/* 101 */ +/***/ (function(module, exports) { + + /* (ignored) */ + +/***/ }), +/* 102 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + + var Buffer = __webpack_require__(96).Buffer; + var util = __webpack_require__(103); + + function copyBuffer(src, target, offset) { + src.copy(target, offset); + } + + module.exports = function () { + function BufferList() { + _classCallCheck(this, BufferList); + + this.head = null; + this.tail = null; + this.length = 0; + } + + BufferList.prototype.push = function push(v) { + var entry = { data: v, next: null }; + if (this.length > 0) this.tail.next = entry;else this.head = entry; + this.tail = entry; + ++this.length; + }; + + BufferList.prototype.unshift = function unshift(v) { + var entry = { data: v, next: this.head }; + if (this.length === 0) this.tail = entry; + this.head = entry; + ++this.length; + }; + + BufferList.prototype.shift = function shift() { + if (this.length === 0) return; + var ret = this.head.data; + if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next; + --this.length; + return ret; + }; + + BufferList.prototype.clear = function clear() { + this.head = this.tail = null; + this.length = 0; + }; + + BufferList.prototype.join = function join(s) { + if (this.length === 0) return ''; + var p = this.head; + var ret = '' + p.data; + while (p = p.next) { + ret += s + p.data; + }return ret; + }; + + BufferList.prototype.concat = function concat(n) { + if (this.length === 0) return Buffer.alloc(0); + if (this.length === 1) return this.head.data; + var ret = Buffer.allocUnsafe(n >>> 0); + var p = this.head; + var i = 0; + while (p) { + copyBuffer(p.data, ret, i); + i += p.data.length; + p = p.next; + } + return ret; + }; + + return BufferList; + }(); + + if (util && util.inspect && util.inspect.custom) { + module.exports.prototype[util.inspect.custom] = function () { + var obj = util.inspect({ length: this.length }); + return this.constructor.name + ' ' + obj; + }; + } + +/***/ }), +/* 103 */ +/***/ (function(module, exports) { + + /* (ignored) */ + +/***/ }), +/* 104 */ +/***/ (function(module, exports, __webpack_require__) { + + 'use strict'; + + /**/ + + var pna = __webpack_require__(93); + /**/ + + // undocumented cb() API, needed for core, not for public API + function destroy(err, cb) { + var _this = this; + + var readableDestroyed = this._readableState && this._readableState.destroyed; + var writableDestroyed = this._writableState && this._writableState.destroyed; + + if (readableDestroyed || writableDestroyed) { + if (cb) { + cb(err); + } else if (err && (!this._writableState || !this._writableState.errorEmitted)) { + pna.nextTick(emitErrorNT, this, err); + } + return this; + } + + // we set destroyed to true before firing error callbacks in order + // to make it re-entrance safe in case destroy() is called within callbacks + + if (this._readableState) { + this._readableState.destroyed = true; + } + + // if this is a duplex stream mark the writable part as destroyed as well + if (this._writableState) { + this._writableState.destroyed = true; + } + + this._destroy(err || null, function (err) { + if (!cb && err) { + pna.nextTick(emitErrorNT, _this, err); + if (_this._writableState) { + _this._writableState.errorEmitted = true; + } + } else if (cb) { + cb(err); + } + }); + + return this; + } + + function undestroy() { + if (this._readableState) { + this._readableState.destroyed = false; + this._readableState.reading = false; + this._readableState.ended = false; + this._readableState.endEmitted = false; + } + + if (this._writableState) { + this._writableState.destroyed = false; + this._writableState.ended = false; + this._writableState.ending = false; + this._writableState.finished = false; + this._writableState.errorEmitted = false; + } + } + + function emitErrorNT(self, err) { + self.emit('error', err); + } + + module.exports = { + destroy: destroy, + undestroy: undestroy + }; + +/***/ }), +/* 105 */ +/***/ (function(module, exports, __webpack_require__) { + + // Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + // a duplex stream is just a stream that is both readable and writable. + // Since JS doesn't have multiple prototypal inheritance, this class + // prototypally inherits from Readable, and then parasitically from + // Writable. + + 'use strict'; + + /**/ + + var pna = __webpack_require__(93); + /**/ + + /**/ + var objectKeys = Object.keys || function (obj) { + var keys = []; + for (var key in obj) { + keys.push(key); + }return keys; + }; + /**/ + + module.exports = Duplex; + + /**/ + var util = Object.create(__webpack_require__(100)); + util.inherits = __webpack_require__(89); + /**/ + + var Readable = __webpack_require__(91); + var Writable = __webpack_require__(106); + + util.inherits(Duplex, Readable); + + { + // avoid scope creep, the keys array can then be collected + var keys = objectKeys(Writable.prototype); + for (var v = 0; v < keys.length; v++) { + var method = keys[v]; + if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method]; + } + } + + function Duplex(options) { + if (!(this instanceof Duplex)) return new Duplex(options); + + Readable.call(this, options); + Writable.call(this, options); + + if (options && options.readable === false) this.readable = false; + + if (options && options.writable === false) this.writable = false; + + this.allowHalfOpen = true; + if (options && options.allowHalfOpen === false) this.allowHalfOpen = false; + + this.once('end', onend); + } + + Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function () { + return this._writableState.highWaterMark; + } + }); + + // the no-half-open enforcer + function onend() { + // if we allow half-open state, or if the writable side ended, + // then we're ok. + if (this.allowHalfOpen || this._writableState.ended) return; + + // no more data can be written. + // But allow more writes to happen in this tick. + pna.nextTick(onEndNT, this); + } + + function onEndNT(self) { + self.end(); + } + + Object.defineProperty(Duplex.prototype, 'destroyed', { + get: function () { + if (this._readableState === undefined || this._writableState === undefined) { + return false; + } + return this._readableState.destroyed && this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (this._readableState === undefined || this._writableState === undefined) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._readableState.destroyed = value; + this._writableState.destroyed = value; + } + }); + + Duplex.prototype._destroy = function (err, cb) { + this.push(null); + this.end(); + + pna.nextTick(cb, err); + }; + +/***/ }), +/* 106 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(process, setImmediate, global) {// Copyright Joyent, Inc. and other Node contributors. + // + // Permission is hereby granted, free of charge, to any person obtaining a + // copy of this software and associated documentation files (the + // "Software"), to deal in the Software without restriction, including + // without limitation the rights to use, copy, modify, merge, publish, + // distribute, sublicense, and/or sell copies of the Software, and to permit + // persons to whom the Software is furnished to do so, subject to the + // following conditions: + // + // The above copyright notice and this permission notice shall be included + // in all copies or substantial portions of the Software. + // + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN + // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, + // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR + // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + // USE OR OTHER DEALINGS IN THE SOFTWARE. + + // A bit simpler than readable streams. + // Implement an async ._write(chunk, encoding, cb), and it'll handle all + // the drain event emission and buffering. + + 'use strict'; + + /**/ + + var pna = __webpack_require__(93); + /**/ + + module.exports = Writable; + + /* */ + function WriteReq(chunk, encoding, cb) { + this.chunk = chunk; + this.encoding = encoding; + this.callback = cb; + this.next = null; + } + + // It seems a linked list but it is not + // there will be only 2 of these for each stream + function CorkedRequest(state) { + var _this = this; + + this.next = null; + this.entry = null; + this.finish = function () { + onCorkedFinish(_this, state); + }; + } + /* */ + + /**/ + var asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick; + /**/ + + /**/ + var Duplex; + /**/ + + Writable.WritableState = WritableState; + + /**/ + var util = Object.create(__webpack_require__(100)); + util.inherits = __webpack_require__(89); + /**/ + + /**/ + var internalUtil = { + deprecate: __webpack_require__(109) + }; + /**/ + + /**/ + var Stream = __webpack_require__(95); + /**/ + + /**/ + + var Buffer = __webpack_require__(96).Buffer; + var OurUint8Array = global.Uint8Array || function () {}; + function _uint8ArrayToBuffer(chunk) { + return Buffer.from(chunk); + } + function _isUint8Array(obj) { + return Buffer.isBuffer(obj) || obj instanceof OurUint8Array; + } + + /**/ + + var destroyImpl = __webpack_require__(104); + + util.inherits(Writable, Stream); + + function nop() {} + + function WritableState(options, stream) { + Duplex = Duplex || __webpack_require__(105); + + options = options || {}; + + // Duplex streams are both readable and writable, but share + // the same options object. + // However, some cases require setting options to different + // values for the readable and the writable sides of the duplex stream. + // These options can be provided separately as readableXXX and writableXXX. + var isDuplex = stream instanceof Duplex; + + // object stream flag to indicate whether or not this stream + // contains buffers or objects. + this.objectMode = !!options.objectMode; + + if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; + + // the point at which write() starts returning false + // Note: 0 is a valid value, means that we always return false if + // the entire buffer is not flushed immediately on write() + var hwm = options.highWaterMark; + var writableHwm = options.writableHighWaterMark; + var defaultHwm = this.objectMode ? 16 : 16 * 1024; + + if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm; + + // cast to ints. + this.highWaterMark = Math.floor(this.highWaterMark); + + // if _final has been called + this.finalCalled = false; + + // drain event flag. + this.needDrain = false; + // at the start of calling end() + this.ending = false; + // when end() has been called, and returned + this.ended = false; + // when 'finish' is emitted + this.finished = false; + + // has it been destroyed + this.destroyed = false; + + // should we decode strings into buffers before passing to _write? + // this is here so that some node-core streams can optimize string + // handling at a lower level. + var noDecode = options.decodeStrings === false; + this.decodeStrings = !noDecode; + + // Crypto is kind of old and crusty. Historically, its default string + // encoding is 'binary' so we have to make this configurable. + // Everything else in the universe uses 'utf8', though. + this.defaultEncoding = options.defaultEncoding || 'utf8'; + + // not an actual buffer we keep track of, but a measurement + // of how much we're waiting to get pushed to some underlying + // socket or file. + this.length = 0; + + // a flag to see when we're in the middle of a write. + this.writing = false; + + // when true all writes will be buffered until .uncork() call + this.corked = 0; + + // a flag to be able to tell if the onwrite cb is called immediately, + // or on a later tick. We set this to true at first, because any + // actions that shouldn't happen until "later" should generally also + // not happen before the first write call. + this.sync = true; + + // a flag to know if we're processing previously buffered items, which + // may call the _write() callback in the same tick, so that we don't + // end up in an overlapped onwrite situation. + this.bufferProcessing = false; + + // the callback that's passed to _write(chunk,cb) + this.onwrite = function (er) { + onwrite(stream, er); + }; + + // the callback that the user supplies to write(chunk,encoding,cb) + this.writecb = null; + + // the amount that is being written when _write is called. + this.writelen = 0; + + this.bufferedRequest = null; + this.lastBufferedRequest = null; + + // number of pending user-supplied write callbacks + // this must be 0 before 'finish' can be emitted + this.pendingcb = 0; + + // emit prefinish if the only thing we're waiting for is _write cbs + // This is relevant for synchronous Transform streams + this.prefinished = false; + + // True if the error was already emitted and should not be thrown again + this.errorEmitted = false; + + // count buffered requests + this.bufferedRequestCount = 0; + + // allocate the first CorkedRequest, there is always + // one allocated and free to use, and we maintain at most two + this.corkedRequestsFree = new CorkedRequest(this); + } + + WritableState.prototype.getBuffer = function getBuffer() { + var current = this.bufferedRequest; + var out = []; + while (current) { + out.push(current); + current = current.next; + } + return out; + }; + + (function () { + try { + Object.defineProperty(WritableState.prototype, 'buffer', { + get: internalUtil.deprecate(function () { + return this.getBuffer(); + }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003') + }); + } catch (_) {} + })(); + + // Test _writableState for inheritance to account for Duplex streams, + // whose prototype chain only points to Readable. + var realHasInstance; + if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') { + realHasInstance = Function.prototype[Symbol.hasInstance]; + Object.defineProperty(Writable, Symbol.hasInstance, { + value: function (object) { + if (realHasInstance.call(this, object)) return true; + if (this !== Writable) return false; + + return object && object._writableState instanceof WritableState; + } + }); + } else { + realHasInstance = function (object) { + return object instanceof this; + }; + } + + function Writable(options) { + Duplex = Duplex || __webpack_require__(105); + + // Writable ctor is applied to Duplexes, too. + // `realHasInstance` is necessary because using plain `instanceof` + // would return false, as no `_writableState` property is attached. + + // Trying to use the custom `instanceof` for Writable here will also break the + // Node.js LazyTransform implementation, which has a non-trivial getter for + // `_writableState` that would lead to infinite recursion. + if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) { + return new Writable(options); + } + + this._writableState = new WritableState(options, this); + + // legacy. + this.writable = true; + + if (options) { + if (typeof options.write === 'function') this._write = options.write; + + if (typeof options.writev === 'function') this._writev = options.writev; + + if (typeof options.destroy === 'function') this._destroy = options.destroy; + + if (typeof options.final === 'function') this._final = options.final; + } + + Stream.call(this); + } + + // Otherwise people can pipe Writable streams, which is just wrong. + Writable.prototype.pipe = function () { + this.emit('error', new Error('Cannot pipe, not readable')); + }; + + function writeAfterEnd(stream, cb) { + var er = new Error('write after end'); + // TODO: defer error events consistently everywhere, not just the cb + stream.emit('error', er); + pna.nextTick(cb, er); + } + + // Checks that a user-supplied chunk is valid, especially for the particular + // mode the stream is in. Currently this means that `null` is never accepted + // and undefined/non-string values are only allowed in object mode. + function validChunk(stream, state, chunk, cb) { + var valid = true; + var er = false; + + if (chunk === null) { + er = new TypeError('May not write null values to stream'); + } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) { + er = new TypeError('Invalid non-string/buffer chunk'); + } + if (er) { + stream.emit('error', er); + pna.nextTick(cb, er); + valid = false; + } + return valid; + } + + Writable.prototype.write = function (chunk, encoding, cb) { + var state = this._writableState; + var ret = false; + var isBuf = !state.objectMode && _isUint8Array(chunk); + + if (isBuf && !Buffer.isBuffer(chunk)) { + chunk = _uint8ArrayToBuffer(chunk); + } + + if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding; + + if (typeof cb !== 'function') cb = nop; + + if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) { + state.pendingcb++; + ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb); + } + + return ret; + }; + + Writable.prototype.cork = function () { + var state = this._writableState; + + state.corked++; + }; + + Writable.prototype.uncork = function () { + var state = this._writableState; + + if (state.corked) { + state.corked--; + + if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state); + } + }; + + Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) { + // node::ParseEncoding() requires lower case. + if (typeof encoding === 'string') encoding = encoding.toLowerCase(); + if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new TypeError('Unknown encoding: ' + encoding); + this._writableState.defaultEncoding = encoding; + return this; + }; + + function decodeChunk(state, chunk, encoding) { + if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') { + chunk = Buffer.from(chunk, encoding); + } + return chunk; + } + + Object.defineProperty(Writable.prototype, 'writableHighWaterMark', { + // making it explicit this property is not enumerable + // because otherwise some prototype manipulation in + // userland will fail + enumerable: false, + get: function () { + return this._writableState.highWaterMark; + } + }); + + // if we're already writing something, then just put this + // in the queue, and wait our turn. Otherwise, call _write + // If we return false, then we need a drain event, so set that flag. + function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) { + if (!isBuf) { + var newChunk = decodeChunk(state, chunk, encoding); + if (chunk !== newChunk) { + isBuf = true; + encoding = 'buffer'; + chunk = newChunk; + } + } + var len = state.objectMode ? 1 : chunk.length; + + state.length += len; + + var ret = state.length < state.highWaterMark; + // we must ensure that previous needDrain will not be reset to false. + if (!ret) state.needDrain = true; + + if (state.writing || state.corked) { + var last = state.lastBufferedRequest; + state.lastBufferedRequest = { + chunk: chunk, + encoding: encoding, + isBuf: isBuf, + callback: cb, + next: null + }; + if (last) { + last.next = state.lastBufferedRequest; + } else { + state.bufferedRequest = state.lastBufferedRequest; + } + state.bufferedRequestCount += 1; + } else { + doWrite(stream, state, false, len, chunk, encoding, cb); + } + + return ret; + } + + function doWrite(stream, state, writev, len, chunk, encoding, cb) { + state.writelen = len; + state.writecb = cb; + state.writing = true; + state.sync = true; + if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite); + state.sync = false; + } + + function onwriteError(stream, state, sync, er, cb) { + --state.pendingcb; + + if (sync) { + // defer the callback if we are being called synchronously + // to avoid piling up things on the stack + pna.nextTick(cb, er); + // this can emit finish, and it will always happen + // after error + pna.nextTick(finishMaybe, stream, state); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + } else { + // the caller expect this to happen before if + // it is async + cb(er); + stream._writableState.errorEmitted = true; + stream.emit('error', er); + // this can emit finish, but finish must + // always follow error + finishMaybe(stream, state); + } + } + + function onwriteStateUpdate(state) { + state.writing = false; + state.writecb = null; + state.length -= state.writelen; + state.writelen = 0; + } + + function onwrite(stream, er) { + var state = stream._writableState; + var sync = state.sync; + var cb = state.writecb; + + onwriteStateUpdate(state); + + if (er) onwriteError(stream, state, sync, er, cb);else { + // Check if we're actually ready to finish, but don't emit yet + var finished = needFinish(state); + + if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) { + clearBuffer(stream, state); + } + + if (sync) { + /**/ + asyncWrite(afterWrite, stream, state, finished, cb); + /**/ + } else { + afterWrite(stream, state, finished, cb); + } + } + } + + function afterWrite(stream, state, finished, cb) { + if (!finished) onwriteDrain(stream, state); + state.pendingcb--; + cb(); + finishMaybe(stream, state); + } + + // Must force callback to be called on nextTick, so that we don't + // emit 'drain' before the write() consumer gets the 'false' return + // value, and has a chance to attach a 'drain' listener. + function onwriteDrain(stream, state) { + if (state.length === 0 && state.needDrain) { + state.needDrain = false; + stream.emit('drain'); + } + } + + // if there's something in the buffer waiting, then process it + function clearBuffer(stream, state) { + state.bufferProcessing = true; + var entry = state.bufferedRequest; + + if (stream._writev && entry && entry.next) { + // Fast case, write everything using _writev() + var l = state.bufferedRequestCount; + var buffer = new Array(l); + var holder = state.corkedRequestsFree; + holder.entry = entry; + + var count = 0; + var allBuffers = true; + while (entry) { + buffer[count] = entry; + if (!entry.isBuf) allBuffers = false; + entry = entry.next; + count += 1; + } + buffer.allBuffers = allBuffers; + + doWrite(stream, state, true, state.length, buffer, '', holder.finish); + + // doWrite is almost always async, defer these to save a bit of time + // as the hot path ends with doWrite + state.pendingcb++; + state.lastBufferedRequest = null; + if (holder.next) { + state.corkedRequestsFree = holder.next; + holder.next = null; + } else { + state.corkedRequestsFree = new CorkedRequest(state); + } + state.bufferedRequestCount = 0; + } else { + // Slow case, write chunks one-by-one + while (entry) { + var chunk = entry.chunk; + var encoding = entry.encoding; + var cb = entry.callback; + var len = state.objectMode ? 1 : chunk.length; + + doWrite(stream, state, false, len, chunk, encoding, cb); + entry = entry.next; + state.bufferedRequestCount--; + // if we didn't call the onwrite immediately, then + // it means that we need to wait until it does. + // also, that means that the chunk and cb are currently + // being processed, so move the buffer counter past them. + if (state.writing) { + break; + } + } + + if (entry === null) state.lastBufferedRequest = null; + } + + state.bufferedRequest = entry; + state.bufferProcessing = false; + } + + Writable.prototype._write = function (chunk, encoding, cb) { + cb(new Error('_write() is not implemented')); + }; + + Writable.prototype._writev = null; + + Writable.prototype.end = function (chunk, encoding, cb) { + var state = this._writableState; + + if (typeof chunk === 'function') { + cb = chunk; + chunk = null; + encoding = null; + } else if (typeof encoding === 'function') { + cb = encoding; + encoding = null; + } + + if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); + + // .end() fully uncorks + if (state.corked) { + state.corked = 1; + this.uncork(); + } + + // ignore unnecessary end() calls. + if (!state.ending && !state.finished) endWritable(this, state, cb); + }; + + function needFinish(state) { + return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing; + } + function callFinal(stream, state) { + stream._final(function (err) { + state.pendingcb--; + if (err) { + stream.emit('error', err); + } + state.prefinished = true; + stream.emit('prefinish'); + finishMaybe(stream, state); + }); + } + function prefinish(stream, state) { + if (!state.prefinished && !state.finalCalled) { + if (typeof stream._final === 'function') { + state.pendingcb++; + state.finalCalled = true; + pna.nextTick(callFinal, stream, state); + } else { + state.prefinished = true; + stream.emit('prefinish'); + } + } + } + + function finishMaybe(stream, state) { + var need = needFinish(state); + if (need) { + prefinish(stream, state); + if (state.pendingcb === 0) { + state.finished = true; + stream.emit('finish'); + } + } + return need; + } + + function endWritable(stream, state, cb) { + state.ending = true; + finishMaybe(stream, state); + if (cb) { + if (state.finished) pna.nextTick(cb);else stream.once('finish', cb); + } + state.ended = true; + stream.writable = false; + } + + function onCorkedFinish(corkReq, state, err) { + var entry = corkReq.entry; + corkReq.entry = null; + while (entry) { + var cb = entry.callback; + state.pendingcb--; + cb(err); + entry = entry.next; + } + if (state.corkedRequestsFree) { + state.corkedRequestsFree.next = corkReq; + } else { + state.corkedRequestsFree = corkReq; + } + } + + Object.defineProperty(Writable.prototype, 'destroyed', { + get: function () { + if (this._writableState === undefined) { + return false; + } + return this._writableState.destroyed; + }, + set: function (value) { + // we ignore the value if the stream + // has not been initialized yet + if (!this._writableState) { + return; + } + + // backward compatibility, the user is explicitly + // managing destroyed + this._writableState.destroyed = value; + } + }); + + Writable.prototype.destroy = destroyImpl.destroy; + Writable.prototype._undestroy = destroyImpl.undestroy; + Writable.prototype._destroy = function (err, cb) { + this.end(); + cb(err); + }; + /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(92), __webpack_require__(107).setImmediate, (function() { return this; }()))) + +/***/ }), +/* 107 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== "undefined" && global) || + (typeof self !== "undefined" && self) || + window; + var apply = Function.prototype.apply; + + // DOM APIs, for completeness + + exports.setTimeout = function() { + return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout); + }; + exports.setInterval = function() { + return new Timeout(apply.call(setInterval, scope, arguments), clearInterval); + }; + exports.clearTimeout = + exports.clearInterval = function(timeout) { + if (timeout) { + timeout.close(); + } + }; + + function Timeout(id, clearFn) { + this._id = id; + this._clearFn = clearFn; + } + Timeout.prototype.unref = Timeout.prototype.ref = function() {}; + Timeout.prototype.close = function() { + this._clearFn.call(scope, this._id); + }; + + // Does not start the time, just sets up the members needed. + exports.enroll = function(item, msecs) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = msecs; + }; + + exports.unenroll = function(item) { + clearTimeout(item._idleTimeoutId); + item._idleTimeout = -1; + }; + + exports._unrefActive = exports.active = function(item) { + clearTimeout(item._idleTimeoutId); + + var msecs = item._idleTimeout; + if (msecs >= 0) { + item._idleTimeoutId = setTimeout(function onTimeout() { + if (item._onTimeout) + item._onTimeout(); + }, msecs); + } + }; + + // setimmediate attaches itself to the global object + __webpack_require__(108); + // On some exotic environments, it's not clear which object `setimmediate` was + // able to install onto. Search each possibility in the same order as the + // `setimmediate` library. + exports.setImmediate = (typeof self !== "undefined" && self.setImmediate) || + (typeof global !== "undefined" && global.setImmediate) || + (this && this.setImmediate); + exports.clearImmediate = (typeof self !== "undefined" && self.clearImmediate) || + (typeof global !== "undefined" && global.clearImmediate) || + (this && this.clearImmediate); + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }), +/* 108 */ +/***/ (function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) { + "use strict"; + + if (global.setImmediate) { + return; + } + + var nextHandle = 1; // Spec says greater than zero + var tasksByHandle = {}; + var currentlyRunningATask = false; + var doc = global.document; + var registerImmediate; + + function setImmediate(callback) { + // Callback can either be a function or a string + if (typeof callback !== "function") { + callback = new Function("" + callback); + } + // Copy function arguments + var args = new Array(arguments.length - 1); + for (var i = 0; i < args.length; i++) { + args[i] = arguments[i + 1]; + } + // Store and register the task + var task = { callback: callback, args: args }; + tasksByHandle[nextHandle] = task; + registerImmediate(nextHandle); + return nextHandle++; + } + + function clearImmediate(handle) { + delete tasksByHandle[handle]; + } + + function run(task) { + var callback = task.callback; + var args = task.args; + switch (args.length) { + case 0: + callback(); + break; + case 1: + callback(args[0]); + break; + case 2: + callback(args[0], args[1]); + break; + case 3: + callback(args[0], args[1], args[2]); + break; + default: + callback.apply(undefined, args); + break; + } + } + + function runIfPresent(handle) { + // From the spec: "Wait until any invocations of this algorithm started before this one have completed." + // So if we're currently running a task, we'll need to delay this invocation. + if (currentlyRunningATask) { + // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a + // "too much recursion" error. + setTimeout(runIfPresent, 0, handle); + } else { + var task = tasksByHandle[handle]; + if (task) { + currentlyRunningATask = true; + try { + run(task); + } finally { + clearImmediate(handle); + currentlyRunningATask = false; + } + } + } + } + + function installNextTickImplementation() { + registerImmediate = function(handle) { + process.nextTick(function () { runIfPresent(handle); }); + }; + } + + function canUsePostMessage() { + // The test against `importScripts` prevents this implementation from being installed inside a web worker, + // where `global.postMessage` means something completely different and can't be used for this purpose. + if (global.postMessage && !global.importScripts) { + var postMessageIsAsynchronous = true; + var oldOnMessage = global.onmessage; + global.onmessage = function() { + postMessageIsAsynchronous = false; + }; + global.postMessage("", "*"); + global.onmessage = oldOnMessage; + return postMessageIsAsynchronous; + } + } + + function installPostMessageImplementation() { + // Installs an event handler on `global` for the `message` event: see + // * https://developer.mozilla.org/en/DOM/window.postMessage + // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages + + var messagePrefix = "setImmediate$" + Math.random() + "$"; + var onGlobalMessage = function(event) { + if (event.source === global && + typeof event.data === "string" && + event.data.indexOf(messagePrefix) === 0) { + runIfPresent(+event.data.slice(messagePrefix.length)); + } + }; + + if (global.addEventListener) { + global.addEventListener("message", onGlobalMessage, false); + } else { + global.attachEvent("onmessage", onGlobalMessage); + } + + registerImmediate = function(handle) { + global.postMessage(messagePrefix + handle, "*"); + }; + } + + function installMessageChannelImplementation() { + var channel = new MessageChannel(); + channel.port1.onmessage = function(event) { + var handle = event.data; + runIfPresent(handle); + }; + + registerImmediate = function(handle) { + channel.port2.postMessage(handle); + }; + } + + function installReadyStateChangeImplementation() { + var html = doc.documentElement; + registerImmediate = function(handle) { + // Create a