From f024b4a3c19bf236af4fbc532c207a46a004e3a3 Mon Sep 17 00:00:00 2001 From: Christian Pierre MOMON Date: Sat, 28 Mar 2020 11:49:11 +0100 Subject: [PATCH] Build 9945bc5f7 --- 00fd86fe12871b707998bf7214820fdd.svg | 15 + 077f1c5bd335be073c48c340b01f58bc.svg | 13 + 0ce7650c4d5a52a5323868f75588e1c7.svg | 30 + 18e00168e2eeff800227594e26818681.svg | 44 + 195ad531e2d729dbb80bb4524be18d78.png | Bin 0 -> 1870 bytes 22ecf0ecde1ae2a6281265174b7fa355.svg | 23 + 296b612d2847da52749549f73d0c3664.svg | 15 + 32785c1d21b0050be9168487542b8c3d.svg | 14 + 33b990984178a1246982bd7dd605f350.css | 469 + 50dddae19e7bf601b168f46a1303674b.svg | 24 + 5b70c2cbbd6e9258a632c70b03381627.png | Bin 0 -> 14901 bytes 6d73bb785aa06bf0c436ad6f7cc6262a.svg | 7 + 71edeaefdc2f5a19dc84298669af6962.svg | 3 + 7b86c879d50808c66816ed3338f26557.svg | 12 + 7dd33815bcb23cf9a0cd851c2145e169.css | 28 + 7e20ba1e3b8980a164c5f557a0470919.ico | Bin 0 -> 15086 bytes 80250154041d2e9f6d50a91181409f21.png | Bin 0 -> 42054 bytes 82747b4bbd0cfe92292f74cd27f2763e.svg | 13 + 86d4f1d7547270ff26f08a9271e7edcb.svg | 23 + 8b61e99b17ef88afd479b3fc990e5b9d.xml | 9 + 8f75583a16890ab851fc3f121fc63f89.svg | 16 + 9171288d67adc4805412883901d2f180.svg | 15 + 93a6487986f6662d71baf41fdeaf0196.png | Bin 0 -> 10998 bytes 972a0ac8cf8526580a216210a364cc60.svg | 7 + 9a1869e4318916bf5e05546eda8d5c43.css | 465 + 9ae3dac014f51d714254cf522602cec0.svg | 11 + 9cda20ca6e5077b6999771c9a8a3cec5.css | 28 + a65db861eecb8dcc62ad70fec489da3f.svg | 14 + b78ed441778f2e4ce1201a75af76594e.svg | 6 + cf02aba975e911ef9823610d908b32f5.png | Bin 0 -> 1047 bytes config.js | 92 + config.local.js | 9 + d57d3d2918d0b72f0c24e9dc162c6c4a.svg | 7 + d5ba30b381ebc262ba3871eaed9d7102.svg | 15 + dbd9efebc73f884c5039cc3192a65dd8.svg | 13 + e0c171776518ab302b54ccc71e59a582.svg | 15 + e72996a6d1ed5d1d7962c27c10c08fa6.json | 17 + ec4d8b884ac39ef8494fb4aca6c6069f.svg | 13 + ee7a19054eb87597c4b8e4664823ebfd.png | Bin 0 -> 14250 bytes f2fc230fc7d9a9b8f6f03d342f6e94b2.svg | 11 + f54b0be1d559b03ad8d945e988ec8ed4.svg | 16 + index.html | 605 + index.js | 52941 ++++++++++++++++++++++++ matrix.js | 493 + theme.js | 2658 ++ 45 files changed, 58209 insertions(+) create mode 100644 00fd86fe12871b707998bf7214820fdd.svg create mode 100644 077f1c5bd335be073c48c340b01f58bc.svg create mode 100644 0ce7650c4d5a52a5323868f75588e1c7.svg create mode 100644 18e00168e2eeff800227594e26818681.svg create mode 100644 195ad531e2d729dbb80bb4524be18d78.png create mode 100644 22ecf0ecde1ae2a6281265174b7fa355.svg create mode 100644 296b612d2847da52749549f73d0c3664.svg create mode 100644 32785c1d21b0050be9168487542b8c3d.svg create mode 100644 33b990984178a1246982bd7dd605f350.css create mode 100644 50dddae19e7bf601b168f46a1303674b.svg create mode 100644 5b70c2cbbd6e9258a632c70b03381627.png create mode 100644 6d73bb785aa06bf0c436ad6f7cc6262a.svg create mode 100644 71edeaefdc2f5a19dc84298669af6962.svg create mode 100644 7b86c879d50808c66816ed3338f26557.svg create mode 100644 7dd33815bcb23cf9a0cd851c2145e169.css create mode 100644 7e20ba1e3b8980a164c5f557a0470919.ico create mode 100644 80250154041d2e9f6d50a91181409f21.png create mode 100644 82747b4bbd0cfe92292f74cd27f2763e.svg create mode 100644 86d4f1d7547270ff26f08a9271e7edcb.svg create mode 100644 8b61e99b17ef88afd479b3fc990e5b9d.xml create mode 100644 8f75583a16890ab851fc3f121fc63f89.svg create mode 100644 9171288d67adc4805412883901d2f180.svg create mode 100644 93a6487986f6662d71baf41fdeaf0196.png create mode 100644 972a0ac8cf8526580a216210a364cc60.svg create mode 100644 9a1869e4318916bf5e05546eda8d5c43.css create mode 100644 9ae3dac014f51d714254cf522602cec0.svg create mode 100644 9cda20ca6e5077b6999771c9a8a3cec5.css create mode 100644 a65db861eecb8dcc62ad70fec489da3f.svg create mode 100644 b78ed441778f2e4ce1201a75af76594e.svg create mode 100644 cf02aba975e911ef9823610d908b32f5.png create mode 100644 config.js create mode 100644 config.local.js create mode 100644 d57d3d2918d0b72f0c24e9dc162c6c4a.svg create mode 100644 d5ba30b381ebc262ba3871eaed9d7102.svg create mode 100644 dbd9efebc73f884c5039cc3192a65dd8.svg create mode 100644 e0c171776518ab302b54ccc71e59a582.svg create mode 100644 e72996a6d1ed5d1d7962c27c10c08fa6.json create mode 100644 ec4d8b884ac39ef8494fb4aca6c6069f.svg create mode 100644 ee7a19054eb87597c4b8e4664823ebfd.png create mode 100644 f2fc230fc7d9a9b8f6f03d342f6e94b2.svg create mode 100644 f54b0be1d559b03ad8d945e988ec8ed4.svg create mode 100644 index.html create mode 100644 index.js create mode 100644 matrix.js create mode 100644 theme.js 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 0000000000000000000000000000000000000000..1fbe564be088a6cd63038f004bbfc11da2fbeb98 GIT binary patch literal 1870 zcmZ`(c|4ox7XC_#V$i8!)b?GmFOgVdk3B(^G#Is0K~Y;QQA^M&y<8MyrnncQ{mGQE zr3R%)>4G(ef>Fq+&|v;eD68uIp=qt_j$j3H&@4Rgf9z25cCZJ zZ$|_cK3hWkV7IHk{~8!XnDrHF2x=`7ISD#{77W1?uRu_$Dg@E)KoAeOXzw8?5e-4? zKnODZ34)|!tGeCIA&9Td&4pzD_3KwHEv?|-U>c29TwGjPSs5N4US3|#U@$&@{OIH3 zQ&LjW)z!7QxJac^-@JLFudkn#m9@FKxv{Y^Iywp9*?)PvpYUM-rwK1 zwzhV4b#-=jW-^(3dwV<{4-7svHI<&8Zfk4%`SWKm+Vu1^fj}UW$v1D_1ViC)xUjIW z!^6WnckbN2ef!|xz{<)BOkrth$>DGST^1G=fTfI#40CgHHk-Y@y`7w#{OQvtGcz+l z+Sb+ZNcPmp<(}jiql9iR! z(9rPn^J6k!&dkideLKFoy5{YD9q91MlSUvaB9YkL{cL4rwX?HJLPA18K@sSxzklGb zzup143VpAZ17vMZA-Z0J1U$1#>)q+|r`YzxgB0%hIv$VP?tVa@_dErG`qJ#vdAj>S zJ2&O{xUP_H3OiJaAnDPC*Lc zioM{nh^*K}#Z&2PHsI+n2zJ&a>`+J`4suW>OL=-qkyRZ8qG*NHIpYGNSd*DqbbVJR zHHyoTm&;-fEY9Aos1)(|chS=1pDY&Z)%f`M&^(JZ|KE!Lh!d{k-1zM4f+j-HdlI!gf-`os!B>qMl(p1jc6Soq>Wjql(S~cP z9#XQEKK_!@KJFy{3zAaO{F=o=eA&OU*?Tp6 z?1ytTHQhXcrJC1lwr_DK0-dJvDhvL-mTuDXsDa+_ROhkABh3Xmy<1cnHP8>Mu*48S z^77SOuHWK5%i^dvoy)x|Z`c9HMQ8~8oB`)mqT_8SdM(M`z`ebm+W%m$zI3+_c%If#4VShff5Jaqx*zoN#ZARM3 z1N!R20dBn#2;mK67GI0o;K`A&=>306>3R$E4N3hYYb~($J1uDqJ-kNK_0G$P2h(sC zv1M#7(TONpFu3*1n1*}Jr`&Q;n{lI54^92Gaj8cN(b4G0H_o*2`JE1}*my)Ai%F=@ z%@gp$7`^%ro%|9Kn2!NsSl*eOXZaob_gqax6kQp2Yu}$K>^^ zOyb#$~ba3iOX<+p`L@sE^CfTUF@_CHW=1W`gwL*he$f%MQABOMGz zN6(mqF)+m#o9bh<&=^xRIz4Usf>i-9b8af#OfXrEkYcXU>a!`CI1b&04 zh+B~fAwjXBsF?V$%5C$@AjvD0^aF($lnlql$B-kULSYIuHWZGCrG!9GO4Z7as8F1z zy87VNp<%)r5#mRRph840Aul + + + + + + + + + + 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 0000000000000000000000000000000000000000..a08d9920338af2d95796202fd354f36a7e7466ca GIT binary patch literal 14901 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 + + + + + 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 0000000000000000000000000000000000000000..7771aaa4db33898044a91a16148c55915f4297ff GIT binary patch literal 15086 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ÆI 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 Bi6Q_1 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..44b148283e699ba24f9703efb3dd2e6ccff42cde GIT binary patch literal 10998 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 literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..df4e45f209475368e5b035536c95ff5ccec5a6c6 GIT binary patch literal 1047 zcmeAS@N?(olHy`uVBq!ia0vp^0wB!63?wyl`GbKJOS+@4BLl<6e(pbstU$g(vPY0F z14ES>14Ba#1H&(%P{RubhEf9thF1v;3|2E37{m+a>uQ@CkAK|NnnMLBaCn z%a0s6a_Q2gg$ox>o;-Qx%$ZxZY}vDC@8!#vKYaLj^XAP(ix%zPz5Dp_6UUDq-@bkO z+_`i6`ue)NyQfT<5)~B{6chwBVd~VWot>R0PMiSBCL|=xm@#ABx^;W@?8(Z?&d<;P z^XG4RdPY`OmZzs@Sy{QeyZf(Szg=BjtE;Q$&!3-?lCovX)*nB9IyyS;-@iXLHg?*y zY2Utm@9gZ_v16yLt?i2!FFt?%VrOTUk&y|s<;$0^EiEnC+1VE^T(q~h@9F7jZ*RYM z?|xcZ+NV#SZ{EBW9UYyKk+FOCo`!~oef#z&Cnx*(_?$R#^6lGq`uh4nPsPW_dwF@? zzyDzI;>Ft9+DS=C@87?lK7D#+Wu=;$T3lS*+qZ8cBO}Yo$`ln9U%!4G78X`lS0^VY zCo3!a^5x5rkPrz8iRaIs`}z3+L+t6(r^}WtYi@47bLY;32M~J#GE->(_N4b5~#T<0n3U|F-`5bNxO@j$d_|I#4lV zlDE4HLkFv@2av;A;1O92r29aaG5h|tlRyT0iKnkC`vY!iK0*0^;=xWpp{JfMjv*44 zlM@)2+|<&<#M0E<*fbJSgF}MC!U9v%TR&J@T)kpyV!CyU=?;qnpYB-gs*3vci>=M= z*c}Jc9vih~tJ0o{O$%$gW~OG-!?S1Gwz6-0eSYVp^wyo*wrvkjP2M}Xd3ka7%Ixy? z)&0w>;rYW@*SO0uK|n@A=+t=y0Wmo_K~6TehYtgpc$zL68g4915Rez1tZ+i%$=n$) zCbF=d?CjKZ;^{fGGV|lhgb5R;X)%@TTM>~~BqouP-qqbSM@w<$Q#|K2Hs4{-+ zSy58h*}gb^Wsk<0-J6O&adCYr+N5B{kdkREY58AC7wBQt64!{5l*E!$tK_0oAjM#0 zU}&amXsBys9%5)>WoT|?Y^ZHuXk}nfoAIdwMMG|WN@iLmZVf!9UM4^dk{}y`^V3So z6N^$A%FE03GV`*FlM@S4_413-XTP(N0xAlx3W+EQN-S3>D9TUE%t=)!sVqoU$Sf#H zW?-n8^Y{}FM`4(T#wq{PXFQ(m_pwD+_y17GV}vaA`0(oWiWUIYi;~jVmXP loH-(Mg#C1b#{w@shF9W(C7+y3rvj~D@O1TaS?83{1OUrfz&ro| literal 0 HcmV?d00001 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 0000000000000000000000000000000000000000..83a08ddf1348549826ab7fa13f8a9eb2c5bfe94f GIT binary patch literal 14250 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 ZL99}dy6(yeeuhUNR20<|isXy~{}*H+Iw$}D literal 0 HcmV?d00001 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